//Desenvolvedor: Jónison Almeida dos Santos
//  <jonisonas@hotmail.com>

#include <cadastro.h>
#include <pdf-new.h>

using namespace std;
using namespace Gtk::Menu_Helpers;

/**
 * Classe Colunas, reponsavel pela criação das treeviews
 */
COLUNAS::COLUNAS()
	{
	//! Classe Colunas
	add (this->descricao);
	add (this->reg);
	add (this->data);
	for(int i=0; i< 5; i++)
		{
		add(campo[i]);
		}
	}
/**
 *
 */
COLUNAS::~COLUNAS()
	{
	
	}

/**
 * Construtor da Classe Cadastro, onde tem como parametro 
 * \param selecao um inteiro que indica qual submenu (janela) está sendo usado no momento
 * \param controle
 * \param conn
 */
CADASTRO::CADASTRO(int selecao, bool *controle, BANCOPG *conn)
	{
	conexao = conn;
	cod_apiario= new char [32];
	this->controle_visualizacao[selecao]= controle;
	this->janela = selecao; 
	this->controle=2;
	this->acao_abelha=0; //pra poder limpar os entrys da abelha_rainha de modo normal
	this->botao_consultar=false;
	this->limite=10;
	this->pagina=0;
	this->pagina_apicol=0;
	this->contar_dados();
	this->carregar_primeiro();
	this->janelas();
	this->consulta_registro=true;
	this->visualizacaosiglas=true;
	this->visualizacaocolmeias=true;
	this->entry_ativa = 0;
	}

/**
 *
 */
CADASTRO::~CADASTRO()
	{

	}

void CADASTRO::sair(Gtk::Window *j)
	{	
	j->hide();
	}

/**
 *
 */
void CADASTRO::Fechou_Janela(int window)
	{
	switch(window)
		{
		case 1:
			{
			Apiarios.hide();
			break;
			}
		/*case 2:
			{
			Colmeias.hide();
			break;
			}*/
		case 3:
			{
			Planilhas->hide();
			break;
			}
		case 4:
			{
			Regioes.hide();
			break;
			}
		case 5:
			{
			Siglas.hide();
			break;
			}
		/*case 6:
			{
			Abelha_Rainha.hide();
			break;
			}*/
		case 7:
			{
			Florada.hide();
			break;
			}
		}
	}
/*
bool CADASTRO::status_janela()
{
	return this->control_janela[this->janela];
}*/

/**
 *
 */
void CADASTRO::janelas()
	{
	switch (this->janela)
		{
		case 1:
			{
			Apiarios.set_title(Glib::ustring("Apiários"));
		  	Apiarios.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
		 	Apiarios.set_position(Gtk::WIN_POS_CENTER);
		  	Apiarios.set_default_size(880, 650);
			Apiarios.signal_hide().connect(sigc::bind(sigc::mem_fun (*this, &CADASTRO::Fechou_Janela),1));
			APrincipal.set_homogeneous(false);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
		 	APrincipal.set_spacing(0);

			AMenu.set_homogeneous(true);
		 	AMenu.set_spacing(0);

			// TOOLBAR DO APIÁRIO

			// CONFIGURANDO NOMES E ICONES:

			tba_novo.set_stock_id(Gtk::Stock::NEW );
			tba_novo.set_tooltip_text("Novo");
			//tba_novo.add_label("Novo");
			tba_salvar.set_stock_id(Gtk::Stock::SAVE);
			tba_salvar.set_tooltip_text("Salvar");
			//tba_salvar.set_label(Glib::ustring("_Salvar"));
			tba_alterar.set_stock_id(Gtk::Stock::EDIT);
			tba_alterar.set_tooltip_text("Alterar");
			//tba_alterar.set_label("_Alterar");
			tba_excluir.set_stock_id(Gtk::Stock::DIALOG_ERROR);
			tba_excluir.set_tooltip_text("Excluir");
			//tba_excluir.set_label("_Excluir");
			tba_cancelar.set_stock_id(Gtk::Stock::CANCEL);
			tba_cancelar.set_tooltip_text("Cancelar");

			//ORDEM DOS ITENS
			tb_apiario.append(tba_novo);
			tb_apiario.append(tba_separador[0]);
			tb_apiario.append(tba_salvar);
			tb_apiario.append(tba_separador[1]);
			tb_apiario.append(tba_alterar);
			tb_apiario.append(tba_separador[2]);
			tb_apiario.append(tba_excluir);
			tb_apiario.append(tba_separador[3]);
			tb_apiario.append(tba_cancelar);

			//Colocando a ação nos toolbar
			tba_novo.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::novo));
			tba_alterar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::editar_registro));
			tba_salvar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::armazenar_registro));
			tba_excluir.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::excluir));
			tba_cancelar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::cancelar));

			tba_salvar.set_sensitive (false);
			tba_cancelar.set_sensitive (false);

			AMenu.pack_start(tb_apiario,false,true,0);
			ADados.set_homogeneous(false);
		 	ADados.set_spacing(0);

			//LABEL DOS CAMPOS

			labNum.set_label(Glib::ustring("Código"));
			labNome.set_label("Nome");
			labRegiao.set_label(Glib::ustring("Região"));
			labSubreg.set_label(Glib::ustring("Sub Região"));
			labLoca.set_label(Glib::ustring("Localização"));
			labData.set_label(Glib::ustring("Data de criação"));

			labFlorada.set_label("Florada");
			labObs.set_label(Glib::ustring("Observação:"));
			labCons.set_label(Glib::ustring("Consulta pelo Código"));

			//REDEFININDO O TAMANHO DAS ENTRYS
			entNum.set_size_request(100,28);
			entNome.set_size_request(250,28);
			entRegiao.signal_activate().connect (sigc::mem_fun(*this, &CADASTRO::gerar_codigo));
			entRegiao.set_tooltip_text(Glib::ustring("Após selecionar a região, aperte enter para o código ser gerado."));
			entSubreg.set_size_request(270,28);
			entLoca.set_size_request(400,28);
			entData.set_size_request(100,28);
			ScrollObs.set_size_request(880,60);
			entCons.set_size_request(100,28);

			ScrollObs.add(TObs);

		 	//Irá mostrar a barra de rolagem somente quando for necessário
		  	ScrollObs.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

		  	//COLOCANDO OS LABELS NA TABELA (PARTE GRAFICA)
			tabela_apiario.put(labNum,10,10);
			tabela_apiario.put(labNome,115,10);
			tabela_apiario.put(labRegiao,370,10);
			tabela_apiario.put(labSubreg, 595,10);
			tabela_apiario.put(labLoca,10,77);
			tabela_apiario.put(labData,420,77);
			tabela_apiario.put(labFlorada, 550,77);
			tabela_apiario.put(labObs,10,140);
			tabela_apiario.put(labCons,10,230);

			//COLOCA OS ENTRYS NA TABELA
			tabela_apiario.put(entNum,10,40);
			tabela_apiario.put(entNome,115,40);
			tabela_apiario.put(entRegiao,370,40);
			tabela_apiario.put(entSubreg,595,40);
			tabela_apiario.put(entLoca,10,104);
			tabela_apiario.put(entData,420,104);
			tabela_apiario.put(CFlorada,550,104);
			tabela_apiario.put(ScrollObs,10,160);
			tabela_apiario.put(entCons,160,225);

			entNum.set_sensitive (false);
			entNome.set_sensitive (false);
			entSubreg.set_sensitive (false);
			entLoca.set_sensitive (false);
			entData.set_sensitive (false);
			ScrollObs.set_sensitive (false);
			entCons.set_sensitive (true);

			entCons.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::maiusculo),1));
			entCons.signal_activate().connect(sigc::mem_fun(*this, &CADASTRO::buscar_registro));

//*****************************************Setando tabulação
			entData.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::configuracao_data),1));
			entData.set_max_length(10);
			entNome.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Apiarios,&this->entRegiao));
			entSubreg.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Apiarios,&this->entLoca));
			entLoca.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Apiarios,&this->entData));
			//entData.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Apiarios,&this->ScrollObs));
			
//************************************COLOCANDO OS BUTTONS

			//tabela_apiario.put(BConsultoutro,300,225); //realizando a busca

			BConsultarapi = Gtk::manage(new Gtk::Image(Gtk::Stock::FIND, Gtk::ICON_SIZE_BUTTON));
			BConsultar.set_image(*BConsultarapi);
			BConsultar.set_tooltip_text(Glib::ustring("Digite o número do registro a ser buscado"));
			BConsultar.signal_clicked().connect(sigc::mem_fun(*this, &CADASTRO::buscar_registro));
					
			BTabela.set_label("Consultar Tabela");
			BTabela.set_tooltip_text(Glib::ustring("Clique para ver a relação de Código e Apiários "));
			BTabela.signal_clicked().connect(sigc::mem_fun(*this, &CADASTRO::tabela_apiarios));
					
//******************Inserindo os Buttons na tabela
			tabela_apiario.put(BConsultar,263,225);
			tabela_apiario.put(BTabela,300,225);
			

			entRegiao.set_sensitive (false);
			CFlorada.set_sensitive (false);
			
			ADados.pack_start(tabela_apiario); //Coloca as entrys e os labels na tabela para depois ser inserida na janela apiario

			APrincipal.pack_start(AMenu,false,true,0);
			APrincipal.pack_start(ADados,false,true,0);
			APrincipal.pack_start(AConsulta,false,true,0);
				
			scrollCliente.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
			scrollCliente.add(listaCliente);
			APrincipal.pack_start(scrollCliente,true,true,0);

			//Botões para Navegação Interna do Scroller
			

			//ADICIONA BOTÕES PARA MUDAR PAGINAS NA TREEVIEW
			//enttotalcolmeias.set_size_request(200,28);
			enttotalcolmeias.set_alignment (Gtk::ALIGN_CENTER);
			//enttotalcolmeias.set_editable(false);
			
			ACImg = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_FIRST, Gtk::ICON_SIZE_BUTTON));
			ACNavini.set_image(*ACImg);
			ACNavini.set_border_width(5);
			ACNavini.set_tooltip_text(Glib::ustring("Primeira Página"));
			ACNavini.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::navega_apicol), 1));

			ACImg = Gtk::manage(new Gtk::Image(Gtk::Stock::GO_BACK, Gtk::ICON_SIZE_BUTTON));
			ACNavant.set_image(*ACImg);
			ACNavant.set_border_width(5);
			ACNavant.set_tooltip_text(Glib::ustring("Página Anterior"));
			ACNavant.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::navega_apicol), 2));

			ACImg= Gtk::manage(new Gtk::Image(Gtk::Stock::GO_FORWARD, Gtk::ICON_SIZE_BUTTON));
			ACNavprox.set_image(*ACImg);
			ACNavprox.set_border_width(5);
			ACNavprox.set_tooltip_text(Glib::ustring("Próxima Página"));
			ACNavprox.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::navega_apicol), 3));

			ACImg = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_BUTTON));
			ACNavfim.set_image(*ACImg);
			ACNavfim.set_border_width(5);
			ACNavfim.set_tooltip_text(Glib::ustring("Ultima Página"));
			ACNavfim.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::navega_apicol), 4));

			navegacaoapiario.set_size_request(200,28);
			navegacaoapiario.set_alignment (Gtk::ALIGN_CENTER);
			navegacaoapiario.set_editable(false);

			//enttotalcolmeias.set_markup("<span font='12'><i><b>Total de Colmeias</b></i></span>");
					
			BApi_col.pack_start(enttotalcolmeias,false,false,0);
			BApi_col.pack_end(ACNavfim,false,false,0);
			BApi_col.pack_end(ACNavprox,false,false,0);
			BApi_col.pack_end(navegacaoapiario,false,false,0);
			BApi_col.pack_end(ACNavant,false,false,0);
			BApi_col.pack_end(ACNavini,false,false,0);
		
			
			APrincipal.pack_start(BApi_col,false,true,0);

			//Box_Fornecedor_Pagina.set_layout(Gtk::BUTTONBOX_SPREAD);

			AIni = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_FIRST, Gtk::ICON_SIZE_BUTTON));
			BNavini.set_image(*AIni);
			BNavini.set_border_width(5);
			BNavini.set_tooltip_text(Glib::ustring("Primeira Página"));
			BNavini.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 1));

			AAnt = Gtk::manage(new Gtk::Image(Gtk::Stock::GO_BACK, Gtk::ICON_SIZE_BUTTON));
			BNavant.set_image(*AAnt);
			BNavant.set_border_width(5);
			BNavant.set_tooltip_text(Glib::ustring("Página Anterior"));
			BNavant.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 2));

			AProx= Gtk::manage(new Gtk::Image(Gtk::Stock::GO_FORWARD, Gtk::ICON_SIZE_BUTTON));
			BNavprox.set_image(*AProx);
			BNavprox.set_border_width(5);
			BNavprox.set_tooltip_text(Glib::ustring("Próxima Página"));
			BNavprox.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 3));

			AFim = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_BUTTON));
			BNavfim.set_image(*AFim);
			BNavfim.set_border_width(5);
			BNavfim.set_tooltip_text(Glib::ustring("Ultima Página"));
			BNavfim.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 4));

			entNav.set_size_request(390,28);
			entNav.set_alignment (Gtk::ALIGN_CENTER);
			
			ANavega.pack_start(BNavini,false,false,0);
			ANavega.pack_start(BNavant,false,false,0);
			ANavega.pack_start(entNav,false,false,0);
			ANavega.pack_start(BNavprox,false,false,0);
			ANavega.pack_start(BNavfim,false,false,0);
			
			APrincipal.pack_start(ANavega,false,true,0);
			Apiarios.add(APrincipal);

			APrincipal.show_all();
			break;
			}
		//Criação da Janela e botões do submenu Colmeias
		case 2:
			{
			Colmeias = new Gtk::Window();
			Colmeias->set_title(Glib::ustring("Colméias"));
		  	Colmeias->set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
		 	Colmeias->set_position(Gtk::WIN_POS_CENTER);
		  	Colmeias->set_default_size(400, 200);
			Colmeias->signal_hide().connect(sigc::bind(sigc::mem_fun (*this, &CADASTRO::sair),Colmeias));

			CPrincipal.set_homogeneous(false);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
		 	CPrincipal.set_spacing(0);

			CMenu.set_homogeneous(true);
		 	CMenu.set_spacing(0);

			// CONFIGURANDO NOMES E ICONES:
			tbc_novo.set_stock_id(Gtk::Stock::NEW );
			tbc_novo.set_tooltip_text("Novo");
			//tba_novo.add_label("Novo");
			tbc_salvar.set_stock_id(Gtk::Stock::SAVE);
			tbc_salvar.set_tooltip_text("Salvar");
			//tba_salvar.set_label(Glib::ustring("_Salvar"));
			tbc_alterar.set_stock_id(Gtk::Stock::EDIT);
			tbc_alterar.set_tooltip_text("Alterar");
			//tba_alterar.set_label("_Alterar");
			tbc_excluir.set_stock_id(Gtk::Stock::DIALOG_ERROR);
			tbc_excluir.set_tooltip_text("Excluir");
			//tba_excluir.set_label("_Excluir");
			tbc_cancelar.set_stock_id(Gtk::Stock::CANCEL);
			tbc_cancelar.set_tooltip_text("Cancelar");

			//ORDEM DOS ITENS
			tb_colmeias.append(tbc_novo);
			tb_colmeias.append(tbc_separador[0]);
			tb_colmeias.append(tbc_salvar);
			tb_colmeias.append(tbc_separador[1]);
			tb_colmeias.append(tbc_alterar);
			tb_colmeias.append(tbc_separador[2]);
			tb_colmeias.append(tbc_cancelar);


			//Colocando a ação nos toolbar
			tbc_novo.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::novo));
			tbc_alterar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::editar_registro));
			tbc_salvar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::armazenar_registro));
			tbc_cancelar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::cancelar));

			tbc_salvar.set_sensitive (false);
			tbc_cancelar.set_sensitive (false);

			CMenu.pack_start(tb_colmeias,false,true,0);
			CDados.set_homogeneous(false);
		 	CDados.set_spacing(0);

			//LABEL DOS CAMPOS
			labCcolmeia.set_label(Glib::ustring("Colméia Nº:"));
			labCdatafor.set_label(Glib::ustring("Data da Formação:"));
			labCtipo.set_label(Glib::ustring("Tipo:"));
			labCatividade.set_label(Glib::ustring("Status:"));
			labCobs.set_label(Glib::ustring("Observação"));
			labCbusca.set_label(Glib::ustring("Buscar Colméia Nº"));

			//REDEFININDO O TAMANHO DAS ENTRYS
			entCcolmeia.set_size_request(60,28);
			entCdatafor.set_size_request(100,28);
			//entCobs.set_size_request(270,28);
			ScrollCobs.set_size_request(270,60);
			entCbusca.set_size_request(60,28);

			ScrollCobs.add(ColObs);
		  //Only show the scrollbars when they are necessary:
		  	ScrollCobs.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
				
			entCbusca.signal_activate().connect(sigc::mem_fun(*this, &CADASTRO::buscar_registro));

			entCdatafor.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::aplicar_mascara),"##/##/####",6,&entCdatafor));
			entCdatafor.signal_activate ().connect (sigc::bind<Gtk::Window*,Gtk::Widget*>(sigc::mem_fun(*this,&CADASTRO::setar_focus),Colmeias,&ColObs));
			entCdatafor.set_max_length(10);

			//entCcolmeia.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Colmeias,&this->entCdatafor));

			//DEFININDO OS LABELS DOS BOTÕES
			//BCconsultar.set_label("Consultar");

			BConsultarcol = Gtk::manage(new Gtk::Image(Gtk::Stock::FIND, Gtk::ICON_SIZE_BUTTON));
			BCconsultar.set_image(*BConsultarcol);
			BCconsultar.set_tooltip_text(Glib::ustring("Digite o número do registro a ser buscado"));
			BCconsultar.signal_clicked().connect(sigc::mem_fun(*this, &CADASTRO::buscar_registro));

		  //COLOCANDO OS LABELS NA TABELA (PARTE GRAFICA)
			tabela_colmeias.put(labCcolmeia,10,30);
			tabela_colmeias.put(labCdatafor,170,30);
			tabela_colmeias.put(labCtipo,10,65);
			tabela_colmeias.put(labCatividade, 220,65);
			tabela_colmeias.put(labCobs,10,110);
			tabela_colmeias.put(labCbusca,10,185);

			//COLOCA OS ENTRYS NA TABELA
			tabela_colmeias.put(entCcolmeia,90,30);
			tabela_colmeias.put(entCdatafor,295,30);
			tabela_colmeias.put(CTipo,45,65);
			tabela_colmeias.put(CAtividade,290,65);
			tabela_colmeias.put(ScrollCobs ,90,110);
			tabela_colmeias.put(entCbusca, 140,185);


			entCcolmeia.set_sensitive (false);
			entCdatafor.set_sensitive (false);
			CTipo.set_sensitive (false);
			CAtividade.set_sensitive (false);
			ColObs.set_editable (false);
			//COLOCANDO OS BUTTONS
			tabela_colmeias.put(BCconsultar,205,185);

			CDados.pack_start(tabela_colmeias);

			//ADICIONA BOTÕES PARA MUDAR PAGINAS

			//Box_Fornecedor_Pagina.set_layout(Gtk::BUTTONBOX_SPREAD);

			CIni = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_FIRST, Gtk::ICON_SIZE_BUTTON));
			CNavini.set_image(*CIni);
			CNavini.set_border_width(5);
			CNavini.set_tooltip_text(Glib::ustring("Primeira Página"));
			CNavini.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 1));

			CAnt = Gtk::manage(new Gtk::Image(Gtk::Stock::GO_BACK, Gtk::ICON_SIZE_BUTTON));
			CNavant.set_image(*CAnt);
			CNavant.set_border_width(5);
			CNavant.set_tooltip_text(Glib::ustring("Página Anterior"));
			CNavant.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 2));

			CProx= Gtk::manage(new Gtk::Image(Gtk::Stock::GO_FORWARD, Gtk::ICON_SIZE_BUTTON));
			CNavprox.set_image(*CProx);
			CNavprox.set_border_width(5);
			CNavprox.set_tooltip_text(Glib::ustring("Próxima Página"));
			CNavprox.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 3));

			CFim = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_BUTTON));
			CNavfim.set_image(*CFim);
			CNavfim.set_border_width(5);
			CNavfim.set_tooltip_text(Glib::ustring("Ultima Página"));
			CNavfim.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 4));

			entNavcolmeias.set_size_request(300,28);
			entNavcolmeias.set_alignment (Gtk::ALIGN_CENTER);

			CNavega.pack_start(CNavini,false,false,0);
			CNavega.pack_start(CNavant,false,false,0);
			CNavega.pack_start(entNavcolmeias,false,false,0);
			CNavega.pack_start(CNavprox,false,false,0);
			CNavega.pack_start(CNavfim,false,false,0);


			CPrincipal.pack_start(CMenu,false,true,0);
			CPrincipal.pack_start(CDados,false,true,0);
			//APrincipal.pack_start(AConsulta,false,true,0);
			CPrincipal.pack_start(CNavega,false,true,0);
			Colmeias->add(CPrincipal);
			CPrincipal.show_all();
			break;
			}
		//Criando TOOLBAR do submenu Planilhas
		case 3:
			{
			Planilhas = new Gtk::Window();
			Planilhas->set_title("Planilhas");
		 	Planilhas->set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
			Planilhas->set_position(Gtk::WIN_POS_CENTER);
			Planilhas->set_default_size(700, 360);
			Planilhas->signal_hide().connect(sigc::bind(sigc::mem_fun (*this, &CADASTRO::Fechou_Janela),3));
			PPrincipal.set_homogeneous(false);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
		 	PPrincipal.set_spacing(0);
			PMenu.set_homogeneous(true);
		  	PMenu.set_spacing(0);

			//Criando TOOLBAR
			// CONFIGURANDO NOMES E ICONES:
			tbp_novo.set_stock_id(Gtk::Stock::NEW );
			tbp_novo.set_tooltip_text("Novo");
			//tba_novo.add_label("Novo");
			tbp_salvar.set_stock_id(Gtk::Stock::SAVE);
			tbp_salvar.set_tooltip_text("Salvar");
			//tba_salvar.set_label(Glib::ustring("_Salvar"));
			tbp_alterar.set_stock_id(Gtk::Stock::EDIT);
			tbp_alterar.set_tooltip_text("Alterar");
			//tba_alterar.set_label("_Alterar");
			tbp_excluir.set_stock_id(Gtk::Stock::DIALOG_ERROR);
			tbp_excluir.set_tooltip_text("Excluir");
			//tba_excluir.set_label("_Excluir");
			tbp_cancelar.set_stock_id(Gtk::Stock::CANCEL);
			tbp_cancelar.set_tooltip_text("Cancelar");
			
			tbp_imprimir.set_stock_id(Gtk::Stock::PRINT);
			tbp_imprimir.set_tooltip_text("Imprimir");

			//ORDEM DOS ITENS
			tb_planilhas.append(tbp_novo);
			tb_planilhas.append(tbp_separador[0]);
			tb_planilhas.append(tbp_salvar);
			tb_planilhas.append(tbp_separador[1]);
			tb_planilhas.append(tbp_alterar);
			tb_planilhas.append(tbp_separador[2]);
			tb_planilhas.append(tbp_excluir);
			tb_planilhas.append(tbp_separador[3]);
			tb_planilhas.append(tbp_cancelar);
			tb_planilhas.append(tbp_separador[4]);
			tb_planilhas.append(tbp_imprimir);

			tbp_novo.set_sensitive (true);
			tbp_salvar.set_sensitive (false);
			tbp_alterar.set_sensitive (true);
			tbp_excluir.set_sensitive (true);
			tbp_cancelar.set_sensitive (false);
			tbp_imprimir.set_sensitive (true);

			tbp_novo.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::novo));
			tbp_alterar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::editar_registro));
			tbp_salvar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::armazenar_registro));
			tbp_excluir.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::excluir));
			tbp_cancelar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::cancelar));
			tbp_imprimir.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::relatorio_planilha));

			PMenu.pack_start(tb_planilhas,false,true,0);

			PDados.set_homogeneous(false);
		 	PDados.set_spacing(0);
			//LABEL DOS CAMPOS
			labPnum.set_label(Glib::ustring("Nº Planilha:"));
			labPdata.set_label("Data:");
			//labPnumap.set_label(Glib::ustring("Nº Apiário:"));
			labPnome.set_label(Glib::ustring("Apiário: "));
			labPregiao.set_label(Glib::ustring("Tipo da  Colmeia:"));
			labPtipo.set_label(Glib::ustring("Tipo da Planilha:"));
		//	labPhrini.set_label(Glib::ustring("Hora Inicial:"));
		//	labPhrfim.set_label("Hora Final:");
		//	labPlua.set_label(Glib::ustring("Lua:"));
			labPobs.set_label(Glib::ustring("OBS:"));
			labPplannum.set_label(Glib::ustring("Buscar Planilha Nº:"));

			//REDEFININDO O TAMANHO DAS ENTRYS
			entPnum.set_size_request(60,28);
			entPdata.set_size_request(90,28);
			//entPnumap.set_size_request(40,28);
			//entPnome.set_size_request(200,28);
			//entPregiao.set_size_request(200,28);
		//	entPhrini.set_size_request(80,28);
		//	entPhrfim.set_size_request(80,28);
			ScrollPlanObs.set_size_request(630,60);
			entPplannum.set_size_request(80,28);
			entPApiario.set_size_request(500,28);

			entPplannum.signal_activate().connect(sigc::mem_fun(*this, &CADASTRO::buscar_registro));
			//Add the TreeView, inside a ScrolledWindow, with the button underneath:
			ScrollPlanObs.add(PlanObs);
		  //Only show the scrollbars when they are necessary:
		  	ScrollPlanObs.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

			entPdata.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),this->Planilhas,&this->entPApiario));
			entPdata.set_max_length(10);
		//	entPApiario.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Planilhas,&this->entPhrini));
		//	entPhrini.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Apiarios,&this->entPhrfim));
			//DEFININDO OS LABELS DOS BOTÕES
			//BPconsultar.set_label("Consultar");

		  //COLOCANDO OS LABELS NA TABELA (PARTE GRAFICA)
			tabela_planilhas.put(labPnum,10,15);
			tabela_planilhas.put(labPdata,180,15);
			//tabela_planilhas.put(labPnumap,10,60);
			tabela_planilhas.put(labPnome, 10,65);
			//tabela_planilhas.put(labPregiao,430,60);
			//tabela_planilhas.put(labPhrini,10,100);
			//tabela_planilhas.put(labPhrfim, 180,100);
			tabela_planilhas.put(labPtipo, 340,15);
			tabela_planilhas.put(labPobs,1,145);
			tabela_planilhas.put(labPplannum,10,235);

			//COLOCA OS ENTRYS NA TABELA
			tabela_planilhas.put(entPnum,90,10);
			tabela_planilhas.put(entPdata,220,10);
			tabela_planilhas.put(entPApiario,60,60);
			//tabela_planilhas.put(entPnome,215,60);
			//tabela_planilhas.put(entPregiao,483,60);
			//tabela_planilhas.put(entPhrini,90,100);
			//tabela_planilhas.put(entPhrfim,255,100);
			tabela_planilhas.put(CBPTipo,445,10);
			tabela_planilhas.put(ScrollPlanObs,60,140);
			tabela_planilhas.put(entPplannum,135,230);

			//COLOCANDO OS BUTTONS
			BPconsultarplan = Gtk::manage(new Gtk::Image(Gtk::Stock::FIND, Gtk::ICON_SIZE_BUTTON));
			BPconsultar.set_image(*BPconsultarplan);
			BPconsultar.set_tooltip_text(Glib::ustring("Digite o número do registro a ser buscado"));
			tabela_planilhas.put(BPconsultar,220,230);
			BPconsultar.signal_clicked().connect(sigc::mem_fun(*this, &CADASTRO::buscar_registro));

			entPdata.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::configuracao_data),5));
				
			//this->carregar_primeiro();
			CBPTipo.set_sensitive (false);

			PDados.pack_start(tabela_planilhas);

     		//ADICIONA BOTÕES PARA MUDAR PAGINAS (Navegação)
			PIni = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_FIRST, Gtk::ICON_SIZE_BUTTON));
			PNavini.set_image(*PIni);
			PNavini.set_border_width(5);
			PNavini.set_tooltip_text(Glib::ustring("Primeira Página"));
			PNavini.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 1));

			PAnt = Gtk::manage(new Gtk::Image(Gtk::Stock::GO_BACK, Gtk::ICON_SIZE_BUTTON));
			PNavant.set_image(*PAnt);
			PNavant.set_border_width(5);
			PNavant.set_tooltip_text(Glib::ustring("Página Anterior"));
			PNavant.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 2));

			PProx= Gtk::manage(new Gtk::Image(Gtk::Stock::GO_FORWARD, Gtk::ICON_SIZE_BUTTON));
			PNavprox.set_image(*PProx);
			PNavprox.set_border_width(5);
			PNavprox.set_tooltip_text(Glib::ustring("Próxima Página"));
			PNavprox.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 3));

			PFim = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_BUTTON));
			PNavfim.set_image(*PFim);
			PNavfim.set_border_width(5);
			PNavfim.set_tooltip_text(Glib::ustring("Ultima Página"));
			PNavfim.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 4));
			entNavplanilhas.set_size_request(290,28);
			entNavplanilhas.set_alignment (Gtk::ALIGN_CENTER);

			PNavega.pack_start(PNavini,false,false,0);
			PNavega.pack_start(PNavant,false,false,0);
			PNavega.pack_start(entNavplanilhas,false,false,0);
			PNavega.pack_start(PNavprox,false,false,0);
			PNavega.pack_start(PNavfim,false,false,0);


			PPrincipal.pack_start(PMenu,false,true,0);
			PPrincipal.pack_start(PDados,false,true,0);
			//PPrincipal.pack_start(PConsulta,false,true,0);
			PPrincipal.pack_start(PNavega,false,true,0);
			Planilhas->add(PPrincipal);

			PPrincipal.show_all();

			entPnum.set_sensitive (false);
			entPdata.set_sensitive (false);
			entPhrini.set_sensitive (false);
			entPhrfim.set_sensitive (false);
			CBPTipo.set_sensitive (false);
			entPApiario.set_sensitive (false);
			ScrollPlanObs.set_sensitive (false);
			entPplannum.set_sensitive (true);
			break;
			}
//Criando os botões do SUBMENU Regiões
		case 4:
			{
			Regioes.set_title(Glib::ustring("Regiões"));
		 	Regioes.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
			Regioes.set_position(Gtk::WIN_POS_CENTER);
		 	Regioes.set_default_size(400, 300);
			Regioes.signal_hide().connect(sigc::bind(sigc::mem_fun (*this, &CADASTRO::Fechou_Janela),4));
			RPrincipal.set_homogeneous(false);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
		 	RPrincipal.set_spacing(0);

			RMenu.set_homogeneous(true);
		 	RMenu.set_spacing(0);

			//Criando TOOLBAR
			// CONFIGURANDO NOMES E ICONES:
			tbr_novo.set_stock_id(Gtk::Stock::NEW );
			tbr_novo.set_tooltip_text("Novo");
			//tba_novo.add_label("Novo");
			tbr_salvar.set_stock_id(Gtk::Stock::SAVE);
			tbr_salvar.set_tooltip_text("Salvar");
			//tba_salvar.set_label(Glib::ustring("_Salvar"));
			tbr_alterar.set_stock_id(Gtk::Stock::EDIT);
			tbr_alterar.set_tooltip_text("Alterar");
			//tba_alterar.set_label("_Alterar");
			tbr_excluir.set_stock_id(Gtk::Stock::DIALOG_ERROR);
			tbr_excluir.set_tooltip_text("Excluir");
			//tba_excluir.set_label("_Excluir");
			tbr_cancelar.set_stock_id(Gtk::Stock::CANCEL);
			tbr_cancelar.set_tooltip_text("Cancelar");
			//tbr_localizar.set_stock_id(Gtk::Stock::FIND);
			//tbr_localizar.set_tooltip_text("Localizar");

			//ORDEM DOS ITENS
			tb_regioes.append(tbr_novo);
			tb_regioes.append(tbr_separador[0]);
			tb_regioes.append(tbr_salvar);
			tb_regioes.append(tbr_separador[1]);
			tb_regioes.append(tbr_alterar);
			tb_regioes.append(tbr_separador[2]);
			tb_regioes.append(tbr_excluir);
			tb_regioes.append(tbr_separador[3]);
			tb_regioes.append(tbr_cancelar);
			//tb_regioes.append(tbr_separador[4]);
			//tb_regioes.append(tbr_localizar);

			tbr_novo.set_sensitive (false);
			tbr_salvar.set_sensitive (false);
			tbr_alterar.set_sensitive (false);
			tbr_excluir.set_sensitive (false);
			tbr_cancelar.set_sensitive (false);

			//tbr_novo.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::novo));
			//tbr_alterar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::editar_registro));
			//tbr_salvar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::armazenar_registro));
			//tbr_localizar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::carregar_regiao));
					
			RMenu.pack_start(tb_regioes,false,true,0);
			RPrincipal.pack_start(RMenu,false,true,0);

			//coloca entry em uma HBOX na janela
				
			entRLocalizar.set_size_request(200,28);
			entRLocalizar.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::checar_nome),4));
				
			BRlocalizarimage = Gtk::manage(new Gtk::Image(Gtk::Stock::FIND, Gtk::ICON_SIZE_BUTTON));
			BRlocaliza.set_image(*BRlocalizarimage);
			BRlocaliza.set_border_width(5);
			BRlocaliza.set_tooltip_text(Glib::ustring("Entre com a cidade"));	
			RLocaliza.pack_start(BRlocaliza, false, false,0);
			RLocaliza.pack_start(entRLocalizar,false,false,0);
			RPrincipal.pack_start(RLocaliza,false,true,0);

		//	RPrincipal.pack_start(RNavega,false,true,0);
				
			//Chamando a função para gerar as colunas
			scrollCliente.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
			scrollCliente.add(listaCliente);
			RPrincipal.pack_start(scrollCliente);
			prepara_box_cliente();

			//ADICIONA BOTÕES PARA MUDAR PAGINAS (Navegação)
			RIni = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_FIRST, Gtk::ICON_SIZE_BUTTON));
			RNavini.set_image(*RIni);
			RNavini.set_border_width(5);
			RNavini.set_tooltip_text(Glib::ustring("Primeira Página"));
			RNavini.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 1));

			RAnt = Gtk::manage(new Gtk::Image(Gtk::Stock::GO_BACK, Gtk::ICON_SIZE_BUTTON));
			RNavant.set_image(*RAnt);
			RNavant.set_border_width(5);
			RNavant.set_tooltip_text(Glib::ustring("Página Anterior"));
			RNavant.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 2));

			RProx= Gtk::manage(new Gtk::Image(Gtk::Stock::GO_FORWARD, Gtk::ICON_SIZE_BUTTON));
			RNavprox.set_image(*RProx);
			RNavprox.set_border_width(5);
			RNavprox.set_tooltip_text(Glib::ustring("Próxima Página"));
			RNavprox.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 3));

			RFim = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_BUTTON));
			RNavfim.set_image(*RFim);
			RNavfim.set_border_width(5);
			RNavfim.set_tooltip_text(Glib::ustring("Ultima Página"));
			RNavfim.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 4));

			entNavregioes.set_size_request(290,28);
			entNavregioes.set_alignment (Gtk::ALIGN_CENTER);

			RNavega.pack_start(RNavini,false,false,0);
			RNavega.pack_start(RNavant,false,false,0);
			RNavega.pack_start(entNavregioes,false,false,0);
			RNavega.pack_start(RNavprox,false,false,0);
			RNavega.pack_start(RNavfim,false,false,0);

			//RPrincipal.pack_start(RNavega,false,true,0);
			Regioes.add(RPrincipal);
			RPrincipal.show_all();
			break;
			}
		//Criando os botões do SUBMENU SIGLAS
		case 5:
			{
			Siglas.set_title(Glib::ustring("Siglas"));
		 	Siglas.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
			Siglas.set_position(Gtk::WIN_POS_CENTER);
		 	Siglas.set_default_size(300, 130);
			Siglas.signal_hide().connect(sigc::bind(sigc::mem_fun (*this, &CADASTRO::Fechou_Janela),5));

			SPrincipal.set_homogeneous(false);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
		 	SPrincipal.set_spacing(0);

			SMenu.set_homogeneous(true);
		 	SMenu.set_spacing(0);

			// CONFIGURANDO NOMES E ICONES:
			tbs_novo.set_stock_id(Gtk::Stock::NEW );
			tbs_novo.set_tooltip_text("Novo");
			//tba_novo.add_label("Novo");
			tbs_salvar.set_stock_id(Gtk::Stock::SAVE);
			tbs_salvar.set_tooltip_text("Salvar");
			//tba_salvar.set_label(Glib::ustring("_Salvar"));
			tbs_alterar.set_stock_id(Gtk::Stock::EDIT);
			tbs_alterar.set_tooltip_text("Alterar");
			//tba_alterar.set_label("_Alterar");
			tbs_excluir.set_stock_id(Gtk::Stock::DIALOG_ERROR);
			tbs_excluir.set_tooltip_text("Excluir");
			//tba_excluir.set_label("_Excluir");
			tbs_cancelar.set_stock_id(Gtk::Stock::CANCEL);
			tbs_cancelar.set_tooltip_text("Cancelar");

			//ORDEM DOS ITENS
			tb_siglas.append(tbs_novo);
			tb_siglas.append(tbs_separador[0]);
			tb_siglas.append(tbs_salvar);
			tb_siglas.append(tbs_separador[1]);
			tb_siglas.append(tbs_alterar);
			tb_siglas.append(tbs_separador[2]);
			tb_siglas.append(tbs_excluir);
			tb_siglas.append(tbs_separador[3]);
			tb_siglas.append(tbs_cancelar);

			tbs_novo.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::novo));
			tbs_alterar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::editar_registro));
			tbs_salvar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::armazenar_registro));
			tbs_excluir.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::excluir));
			tbs_cancelar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::cancelar));

			tbs_salvar.set_sensitive (false);
			tbs_cancelar.set_sensitive (false);

			SMenu.pack_start(tb_siglas,false,true,0);
			SPrincipal.pack_start(SMenu,false,true,0);
			Siglas.add(SPrincipal);
			SPrincipal.show_all();

			SDados.set_homogeneous(false);
		 	SDados.set_spacing(0);

			//LABEL DOS CAMPOS
			labSiglas.set_label("Sigla");
			labMunicipio.set_label(Glib::ustring("Município"));

			//REDEFININDO O TAMANHO DAS ENTRYS
			entSiglas.set_size_request(50,28);
			entSiglas.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::checar_nome),5));

			tabela_siglas.put(labSiglas,260,10);
			tabela_siglas.put(labMunicipio,10,10);

			tabela_siglas.put(entSiglas,295,5);
			tabela_siglas.put(entSiglasPreencher,80,5);
			this->listagem_box(3);
			SDados.pack_start(tabela_siglas);
			SPrincipal.pack_start(SDados,false,true,0);

			entSiglasPreencher.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Apiarios,&this->entSiglas));
			//entSiglas.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Apiarios,&this->tbs_salvar));
			entSiglas.set_sensitive (false);
			//CSiglas.set_sensitive (false);
			entSiglasPreencher.set_sensitive(false);

			//ADICIONA BOTÕES PARA MUDAR PAGINAS
			SIni = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_FIRST, Gtk::ICON_SIZE_BUTTON));
			SNavini.set_image(*SIni);
			SNavini.set_border_width(5);
			SNavini.set_tooltip_text(Glib::ustring("Primeira Página"));
			SNavini.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 1));

			SAnt = Gtk::manage(new Gtk::Image(Gtk::Stock::GO_BACK, Gtk::ICON_SIZE_BUTTON));
			SNavant.set_image(*SAnt);
			SNavant.set_border_width(5);
			SNavant.set_tooltip_text(Glib::ustring("Página Anterior"));
			SNavant.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 2));

			SProx= Gtk::manage(new Gtk::Image(Gtk::Stock::GO_FORWARD, Gtk::ICON_SIZE_BUTTON));
			SNavprox.set_image(*SProx);
			SNavprox.set_border_width(5);
			SNavprox.set_tooltip_text(Glib::ustring("Próxima Página"));
			SNavprox.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 3));

			SFim = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_BUTTON));
			SNavfim.set_image(*SFim);
			SNavfim.set_border_width(5);
			SNavfim.set_tooltip_text(Glib::ustring("Ultima Página"));
			SNavfim.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 4));

			entNavsiglas.set_size_request(290,28);
			entNavsiglas.set_alignment (Gtk::ALIGN_CENTER);

			SNavega.pack_start(SNavini,false,false,0);
			SNavega.pack_start(SNavant,false,false,0);
			SNavega.pack_start(entNavsiglas,false,false,0);
			SNavega.pack_start(SNavprox,false,false,0);
			SNavega.pack_start(SNavfim,false,false,0);
			SPrincipal.pack_start(SNavega,false,true,0);
			SPrincipal.show_all();

			break;
			}

		//Criando os botões do SUBMENU ABELHA RAINHA
		case 6:
			{
			Abelha_Rainha = new Gtk::Window();
			Abelha_Rainha->set_title(Glib::ustring("Cadastro Abelha Rainha"));
		 	Abelha_Rainha->set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
		 	Abelha_Rainha->set_position(Gtk::WIN_POS_CENTER);
			Abelha_Rainha->set_default_size(600, 400);
			Abelha_Rainha->signal_hide().connect(sigc::bind(sigc::mem_fun (*this, &CADASTRO::sair),Abelha_Rainha));

			ARPrincipal.set_homogeneous(false);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
		 	ARPrincipal.set_spacing(0);

			ARMenu.set_homogeneous(true);
		 	ARMenu.set_spacing(0);

		// TOOLBAR DO APIÁRIO

			// CONFIGURANDO NOMES E ICONES:
			tbar_novo.set_stock_id(Gtk::Stock::NEW );
			tbar_novo.set_tooltip_text("Novo");
			//tba_novo.add_label("Novo");
			tbar_salvar.set_stock_id(Gtk::Stock::SAVE);
			tbar_salvar.set_tooltip_text("Salvar");
			//tba_salvar.set_label(Glib::ustring("_Salvar"));
			tbar_alterar.set_stock_id(Gtk::Stock::EDIT);
			tbar_alterar.set_tooltip_text("Alterar");
			//tba_alterar.set_label("_Alterar");
			tbar_excluir.set_stock_id(Gtk::Stock::DIALOG_ERROR);
			tbar_excluir.set_tooltip_text("Excluir");
			//tba_excluir.set_label("_Excluir");
			tbar_cancelar.set_stock_id(Gtk::Stock::CANCEL);
			tbar_cancelar.set_tooltip_text("Cancelar");

			//ORDEM DOS ITENS
			tb_rainhas.append(tbar_novo);
			tb_rainhas.append(tbar_separador[0]);
			tb_rainhas.append(tbar_salvar);
			tb_rainhas.append(tbar_separador[1]);
			tb_rainhas.append(tbar_alterar);
			tb_rainhas.append(tbar_separador[2]);
			tb_rainhas.append(tbar_excluir);
			tb_rainhas.append(tbar_separador[3]);
			tb_rainhas.append(tbar_cancelar);



			//Colocando a ação nos toolbar
			tbar_novo.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::novo));
			tbar_alterar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::editar_registro));
			tbar_salvar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::armazenar_registro));
			tbar_excluir.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::excluir));
			tbar_cancelar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::cancelar));

			ARMenu.pack_start(tb_rainhas,false,true,0);
			tbar_novo.set_sensitive (true);
			tbar_salvar.set_sensitive (false);
			tbar_alterar.set_sensitive (true);
			tbar_excluir.set_sensitive (true);
			tbar_cancelar.set_sensitive (false);

			ARDados.set_homogeneous(false);
			ARDados.set_spacing(0);
		
			//LABEL DOS CAMPOS
			labarrg.set_label(Glib::ustring("Identificação:"));
			labarcodatual.set_label(Glib::ustring("Código Atual:"));
			labarcodnovo.set_label(Glib::ustring("Novo Código:"));
			labardatanas.set_label(Glib::ustring("Data de Nascimento:"));
			labardatafec.set_label(Glib::ustring("Data de Fecundação:"));
			labardatarev.set_label(Glib::ustring("Local de Nascimento:"));
			labargera.set_label(Glib::ustring("Geração:"));
			labarrgmae.set_label(Glib::ustring("Identificação da Mãe:"));
			labarconsultar.set_label(Glib::ustring("Consultar Identificação:"));
			labarObs.set_label(Glib::ustring("OBS:"));
			labarcolmeia.set_label(Glib::ustring("Colméia / Data Criação"));

			entarconsultar.signal_activate().connect(sigc::mem_fun(*this, &CADASTRO::buscar_registro));	
			//REDEFININDO O TAMANHO DAS ENTRYS
			entarrg.set_size_request(100,28);
			entarrg.set_alignment (Gtk::ALIGN_CENTER);
			entarcodatual.set_size_request(100,28);
			entarcodatual.set_alignment (Gtk::ALIGN_CENTER);
			entarcodnovo.set_size_request(120,28);
			entarcodnovo.set_alignment (Gtk::ALIGN_CENTER);
			entardatanas.set_size_request(100,28);
			entardatanas.set_alignment (Gtk::ALIGN_CENTER);
			entardatafec.set_size_request(100,28);
			entardatafec.set_alignment (Gtk::ALIGN_CENTER);
			ent_ARloca.set_size_request(400,28);
			CBRainha.set_size_request(100,28);
			entarrgmae.set_alignment (Gtk::ALIGN_CENTER);
			entargera.set_size_request(100,28);
			entargera.set_alignment (Gtk::ALIGN_CENTER);
			ScrollarObs.set_size_request(400,60);
			entarconsultar.set_size_request(100,28);
			entarconsultar.set_alignment (Gtk::ALIGN_CENTER);
			
			//Add the TreeView, inside a ScrolledWindow, with the button underneath:

			ScrollarObs.add(RainhaObs);

		  //Only show the scrollbars when they are necessary:
		  	ScrollarObs.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

			//DEFININDO OS LABELS DOS BOTÕES
			//BarConsultar.set_label("Consultar");

		  //COLOCANDO OS LABELS NA TABELA (PARTE GRAFICA)
			tabela_rainhas.put(labarrg,10,10);
			tabela_rainhas.put(labarcodatual,170,10);
			tabela_rainhas.put(labarcodnovo,330,10);
			tabela_rainhas.put(labardatanas,10,77);
			tabela_rainhas.put(labardatafec,170,77);
			tabela_rainhas.put(labardatarev,330,77);
			tabela_rainhas.put(labargera, 10,144);
			tabela_rainhas.put(labarrgmae,170,144);
			tabela_rainhas.put(labarcolmeia, 330, 144);
			tabela_rainhas.put(labarObs,10,220);
			tabela_rainhas.put(labarconsultar,10,300);
			


			//COLOCA OS ENTRYS NA TABELA
			tabela_rainhas.put(entarrg,10,30);
			tabela_rainhas.put(entarcodatual,170,30);
			tabela_rainhas.put(entarcodnovo,330,30);
			tabela_rainhas.put(entardatanas, 10,97);
			tabela_rainhas.put(entardatafec,170,97);
			tabela_rainhas.put(ent_ARloca,330,97);
			tabela_rainhas.put(entargera, 10,164);
			tabela_rainhas.put(CBRainha,170,164);
			tabela_rainhas.put(CBRcolmeia, 330,164);
			tabela_rainhas.put(ScrollarObs,60,210);
			tabela_rainhas.put(entarconsultar,10,320);
				
			entarcodatual.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::checar_digito),&entarcodatual)); //fun ção para aceitar apenas digitos

			entardatanas.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::aplicar_mascara),"##/##/####",2,&entardatanas));
			entardatafec.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::aplicar_mascara),"##/##/####",3,&entardatafec));
			entarrg.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::checar_digito),&entarrg));

			CBRcolmeia.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::checar_digito),&CBRcolmeia)); //função para aceitar apenas numeros
			CBRcolmeia.signal_activate ().connect(sigc::mem_fun(*this,&CADASTRO::sel_colmeia));


			entarcodatual.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),Abelha_Rainha,&this->entardatanas));
			entardatanas.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),Abelha_Rainha,&this->entardatafec));
			entardatafec.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),Abelha_Rainha,&this->ent_ARloca));
			ent_ARloca.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),Abelha_Rainha,&this->entargera));
			entargera.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),Abelha_Rainha,&this->CBRcolmeia));

			entardatanas.set_max_length(10);
			entardatafec.set_max_length(10);
		
			Bconsultarar = Gtk::manage(new Gtk::Image(Gtk::Stock::FIND, Gtk::ICON_SIZE_BUTTON));
			BarConsultar.set_image(*Bconsultarar);
			tabela_rainhas.put(BarConsultar,130,320);
			BarConsultar.set_tooltip_text(Glib::ustring("Digite o número do registro a ser buscado"));
			BarConsultar.signal_clicked().connect(sigc::mem_fun(*this, &CADASTRO::buscar_registro));

		//	cout<<"Chequei aqui 1 abelha rainha"<<endl;

			//COLOCANDO OS BUTTONS
			//tabela_rainhas.put(BarConsultar,130,320);

			ARDados.pack_start(tabela_rainhas);

			entarrg.set_sensitive (false);
			entarcodatual.set_sensitive (false);
			entarcodnovo.set_sensitive (false);
			entardatanas.set_sensitive (false);
			entardatafec.set_sensitive (false);
			entargera.set_sensitive (false);
			CBRainha.set_sensitive (false);
			CBRcolmeia.set_sensitive (false);
			ScrollarObs.set_sensitive (false);
			entarconsultar.set_sensitive (true);

			//ADICIONA BOTÕES PARA MUDAR PAGINAS

			ARIni = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_FIRST, Gtk::ICON_SIZE_BUTTON));
			ARNavini.set_image(*ARIni);
			ARNavini.set_border_width(5);
			ARNavini.set_tooltip_text(Glib::ustring("Primeira Página"));
			ARNavini.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 1));

			ARAnt = Gtk::manage(new Gtk::Image(Gtk::Stock::GO_BACK, Gtk::ICON_SIZE_BUTTON));
			ARNavant.set_image(*ARAnt);
			ARNavant.set_border_width(5);
			ARNavant.set_tooltip_text(Glib::ustring("Página Anterior"));
			ARNavant.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 2));

			ARProx= Gtk::manage(new Gtk::Image(Gtk::Stock::GO_FORWARD, Gtk::ICON_SIZE_BUTTON));
			ARNavprox.set_image(*ARProx);
			ARNavprox.set_border_width(5);
			ARNavprox.set_tooltip_text(Glib::ustring("Próxima Página"));
			ARNavprox.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 3));

			ARFim = Gtk::manage(new Gtk::Image(Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_BUTTON));
			ARNavfim.set_image(*ARFim);
			ARNavfim.set_border_width(5);
			ARNavfim.set_tooltip_text(Glib::ustring("Ultima Página"));
			ARNavfim.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::troca_pagina), 4));

			entNavrainhas.set_size_request(290,28);
			entNavrainhas.set_alignment (Gtk::ALIGN_CENTER);

			ARNavega.pack_start(ARNavini,false,false,0);
			ARNavega.pack_start(ARNavant,false,false,0);
			ARNavega.pack_start(entNavrainhas,false,false,0);
			ARNavega.pack_start(ARNavprox,false,false,0);
			ARNavega.pack_start(ARNavfim,false,false,0);

			ARPrincipal.pack_start(ARMenu,false,true,0);
			ARPrincipal.pack_start(ARDados,false,true,0);
		//	ARPrincipal.pack_start(ARConsulta,false,true,0);
			ARPrincipal.pack_start(ARNavega,false,true,0);
			Abelha_Rainha->add(ARPrincipal);

			//ARPrincipal.show_all();
			break;
			}
		case 7:
			{
			Florada.set_title(Glib::ustring("Florada"));
			Florada.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
			Florada.set_position(Gtk::WIN_POS_CENTER);
			Florada.set_default_size(250, 150);
		//	Apiarios.signal_show().connect(sigc::mem_fun (*this, &CADASTRO::Carregou_Janela));
			Florada.signal_hide().connect(sigc::bind(sigc::mem_fun (*this, &CADASTRO::Fechou_Janela),7));
			FPrincipal.set_homogeneous(false);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
			FPrincipal.set_spacing(0);

			FMenu.set_homogeneous(true);
			FMenu.set_spacing(0);

			// TOOLBAR DO APIÁRIO

			// CONFIGURANDO NOMES E ICONES:

			//tbf_novo.set_stock_id(Gtk::Stock::NEW );
			//tbf_novo.set_tooltip_text("Novo");
			//tba_novo.add_label("Novo");
			tbf_salvar.set_stock_id(Gtk::Stock::SAVE);
			tbf_salvar.set_tooltip_text("Salvar");
			//tba_salvar.set_label(Glib::ustring("_Salvar"));
			/*tbf_alterar.set_stock_id(Gtk::Stock::EDIT);
			tbf_alterar.set_tooltip_text("Alterar");
			//tba_alterar.set_label("_Alterar");
			tbf_excluir.set_stock_id(Gtk::Stock::DIALOG_ERROR);
			tbf_excluir.set_tooltip_text("Excluir");
			//tba_excluir.set_label("_Excluir");*/
			tbf_cancelar.set_stock_id(Gtk::Stock::CANCEL);
			tbf_cancelar.set_tooltip_text("Cancelar");

			//ORDEM DOS ITENS
			//tb_florada.append(tbf_novo);
			tb_florada.append(tbf_separador[0]);
			tb_florada.append(tbf_salvar);
			tb_florada.append(tbf_separador[1]);
			//tb_florada.append(tbf_alterar);
			//tb_florada.append(tbf_separador[2]);
			//tb_florada.append(tbf_excluir);
			//tb_florada.append(tbf_separador[3]);
			tb_florada.append(tbf_cancelar);

			//Colocando a ação nos toolbar
	//		tba_novo.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::novo));
	//		tba_alterar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::editar_registro));
			tba_salvar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::armazenar_registro));
	//		tba_excluir.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::excluir));
			tba_cancelar.signal_clicked().connect( sigc::mem_fun(*this, &CADASTRO::cancelar));

			tba_salvar.set_sensitive (false);
			tba_cancelar.set_sensitive (false);
			
			FMenu.pack_start(tb_florada,false,true,0);

			lab_florada.set_label("Entre com o tipo de Florada: ");
			ent_Florada.set_size_request(130,28);
				
			FMeio.pack_start(lab_florada,false,true,0);
			FFim.pack_start(ent_Florada,false,true,0);
				
			FPrincipal.pack_start(FMenu, false, false,0);
			FPrincipal.pack_start(FMeio, false, false,0);
			FPrincipal.pack_start(FFim, false, false,0);
			Florada.add(FPrincipal);
			FPrincipal.show_all ();
			Florada.set_focus(this->ent_Florada);
			break;
			}
		}
	}

/**
 * \param opc
 */
void CADASTRO :: listagem_box(int opc)
	{
	string SQL, servico, dados, apiario, Aux;
	int i, total, id_reg;
	char *sql, *concatena, *sqlregiao, *cod_regiao, *sqlar, *cod_rg, *colmeia, *Data_formatada;
	vector<vector<string> >::iterator ir;
	vector<string> linha;
	
	switch (opc)
		{
		case 1:
			{
			int i,total;
			Glib::RefPtr<Gtk::EntryCompletion> completion =  Gtk::EntryCompletion::create();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			completion->set_model(arvore_ref);
			entRegiao.set_completion(completion);
			SQL.clear();
			SQL = "select cod_cid, nome from cadastro.municipio where estado='MS'";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			conexao->executar(sql);
			delete sql;
			total=this->conexao->registros;
			this->conexao->resultado();
			for(ir=this->conexao->resultados.begin();ir<this->conexao->resultados.end();ir++)
				{
				linha = *ir;
				celula = *(arvore_ref->append());
				celula[arvore_reg.reg] = atoi(linha.at(0).c_str());
				celula[arvore_reg.descricao]= linha.at(1);
				}
			completion->set_text_column(arvore_reg.descricao);

			for(type_actions_map::iterator iter = m_CompletionActions.begin();iter != m_CompletionActions.end(); ++iter)
				{
				int position = iter->first;
				Glib::ustring title = iter->second;
				completion->insert_action_text(title, position);
				}
			if(this->visualizacao==false)
				{
				cod_regiao= new char [33];
				sprintf(cod_regiao,"%d",this->cod_reg);
				dados.clear();
				dados = "select nome, cod_cid from cadastro.municipio where estado='MS' and cod_cid=" ;
				dados.append(cod_regiao);
				delete cod_regiao;
				sqlregiao = new char[dados.length()+1];
				strcpy(sqlregiao,dados.c_str());
			    this->conexao->executar(sqlregiao);
				delete sqlregiao;
				this->conexao->resultado();
				ir = this->conexao->resultados.begin();
				linha = *ir;
				this->entRegiao.set_text(linha.at(0));
				}
			break;
			}
		case 2:
			{
			CFlorada.clear();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			CFlorada.set_model(arvore_ref);
			SQL.clear();
			SQL = "select * from cadastro.florada order by descricao";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str ());
			this->conexao->executar(sql);
			delete sql;
			total = this->conexao->registros;
			this->conexao->resultado();
			for(ir=this->conexao->resultados.begin();ir<this->conexao->resultados.end();ir++)
				{
				linha = *ir;
				celula = *(arvore_ref->append());
				celula[arvore_reg.reg] = atoi(linha.at(0).c_str());
				celula[arvore_reg.descricao]= linha.at(1);
				if(atoi(linha.at(0).c_str()) == this->cod_florada)
					{
					id_reg=i;
					}
				}
			CFlorada.set_active(id_reg);//arrumar
			break;
			}
		case 3:
			{
			CTipo.clear();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			CTipo.set_model(arvore_ref);
			celula = *(arvore_ref->append());
			celula[arvore_reg.reg] = 0;
			celula[arvore_reg.descricao]= "Desenvolvimento";
			celula = *(arvore_ref->append());
			celula[arvore_reg.reg] = 1;
			celula[arvore_reg.descricao]= Glib::ustring("Produção");
			CTipo.set_active(this->cod_tp);
			break;
			}
		case 4:
			{
			CAtividade.clear();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			CAtividade.set_model(arvore_ref);
			celula = *(arvore_ref->append());
			celula[arvore_reg.reg] = 0;
			celula[arvore_reg.descricao]= "Inativo";
			celula = *(arvore_ref->append());
			celula[arvore_reg.reg] = 1;
			celula[arvore_reg.descricao]= Glib::ustring("Ativo");
			CAtividade.set_active(this->cod_st);
			break;
			}
		case 5:
			{
			CBPTipo.clear();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			CBPTipo.set_model(arvore_ref);
			celula = *(arvore_ref->append());
			celula[arvore_reg.reg] = 0;
			celula[arvore_reg.descricao]= "Desenvolvimento";
			celula = *(arvore_ref->append());
			celula[arvore_reg.reg] = 1;
			celula[arvore_reg.descricao]= Glib::ustring("Produção");
		    celula = *(arvore_ref->append());
			celula[arvore_reg.reg] = 2;
			celula[arvore_reg.descricao]= Glib::ustring("Fecundação");
			celula = *(arvore_ref->append());                        
		//	celula[arvore_reg.reg] = 3;
		//	celula[arvore_reg.descricao]= Glib::ustring("Crescente");
			CBPTipo.set_active(this->tipo_planilha);
			break;
			}
		case 6:
			{
			Glib::RefPtr<Gtk::EntryCompletion> completion =  Gtk::EntryCompletion::create();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			completion->set_model(arvore_ref);
			entPApiario.set_completion(completion);
			SQL.clear();
			SQL = "select id_api,nome,local,sub_regiao from cadastro.apiarios order by nome";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			total=this->conexao->registros;
			if (total > 0)
				{
				this->conexao->resultado();
				for(ir=this->conexao->resultados.begin();ir<this->conexao->resultados.end();ir++)
					{					
					linha = *ir;
					apiario.clear();
					celula = *(arvore_ref->append());
					celula[arvore_reg.reg] = atoi(linha.at(0).c_str());
					apiario=linha.at(1)+"/"+linha.at(2)+"/"+=linha.at(3)+"<"+linha.at(0);
					apiario+=">";
					celula[arvore_reg.descricao]= apiario;
					}
				completion->set_text_column(arvore_reg.descricao);

				for(type_actions_map::iterator iter = m_CompletionActions.begin();iter != m_CompletionActions.end(); ++iter)
					{
					int position = iter->first;
					Glib::ustring title = iter->second;
					completion->insert_action_text(title, position);
					}

				sprintf(cod_apiario,"%d",this->cod_api);
				dados.clear();
				dados = "select id_api,nome,local,sub_regiao from cadastro.apiarios where id_api=";
				dados.append (cod_apiario);
				sqlregiao = new char[dados.length()+1];
				strcpy(sqlregiao,dados.c_str());
				this->conexao->executar(sqlregiao);
				delete sqlregiao;
				if (conexao->registros > 0)
					{
					this->conexao->resultado();
					ir = this->conexao->resultados.begin();
					linha = *ir;
					dados.clear();
					dados=linha.at(1)+" ; "+linha.at(2)+" ; "+linha.at(3);
					this->entPApiario.set_text(dados);
					}
				}
			break;
			}
		case 7:
			{
			Glib::RefPtr<Gtk::EntryCompletion> completion =  Gtk::EntryCompletion::create();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			completion->set_model(arvore_ref);
			entSiglasPreencher.set_completion(completion);
			SQL.clear();
			if(this->controle == 1) //Controle 1 para inserção e 2 para visualização
				{
				SQL = "(select cod_cid, nome from cadastro.municipio where estado='MS' except select cod_cid, nome from cadastro.siglas natural join cadastro.municipio)  order by nome";
				}
			else
				{
				SQL = "select cod_cid, nome from cadastro.municipio where estado='MS'";
				}
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			total=this->conexao->registros;
			this->conexao->resultado();
			for(ir=this->conexao->resultados.begin();ir<this->conexao->resultados.end();ir++)
				{
				linha = *ir;
				servico.clear();
				celula = *(arvore_ref->append());
				celula[arvore_reg.reg] = atoi(linha.at(0).c_str());
				celula[arvore_reg.descricao]= linha.at(1);
				}
			completion->set_text_column(arvore_reg.descricao);

			for(type_actions_map::iterator iter = m_CompletionActions.begin();iter != m_CompletionActions.end(); ++iter)
				{
				int position = iter->first;
				Glib::ustring title = iter->second;
				completion->insert_action_text(title, position);
				}
			if(this->visualizacaosiglas==true)
				{
				cod_regiao = new char[32];
				sprintf (cod_regiao,"%d",this->cod_reg);
				dados.clear();
				dados = "select nome, cod_cid from cadastro.municipio where estado='MS' and cod_cid=" ;
				dados.append(cod_regiao);
				delete cod_regiao;
				sqlregiao = new char[dados.length()+1];
				strcpy(sqlregiao,dados.c_str());
				this->conexao->executar(sqlregiao);
				delete sqlregiao;
				this->conexao->resultado();
				ir = this->conexao->resultados.begin();
				linha = *ir;
				this->entSiglasPreencher.set_text(linha.at(0));
				}
			break;
			}
		case 8: //se precisar usar combobox na abelha_rainha
			{
			SQL.clear();
			SQL = "select rg from cadastro.abelha_rainha";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			//cout<<sql<<endl;
			CBRainha.clear();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			CBRainha.set_model(arvore_ref);
			this->conexao->executar(sql);
			delete sql;
			total = this->conexao->registros;
			celula = *(arvore_ref->append());
			celula[arvore_reg.reg] = 0;
			celula[arvore_reg.descricao]= "";
			id_reg=0;
			if (total > 0)
				{
				this->conexao->resultado();
				
				for(ir=this->conexao->resultados.begin();ir<this->conexao->resultados.end();ir++)
					{
					linha = *ir;
					celula = *(arvore_ref->append());
					celula[arvore_reg.reg] = atoi(linha.at(0).c_str());
					celula[arvore_reg.descricao]= linha.at(0);
					if(atoi(linha.at(0).c_str()) == this->cod_abelha)
						{
						id_reg=i+1;
						}
					}
				}
			CBRainha.set_active(id_reg);
			break;
			}
		case 9:
			{
			this->id_colmeia.clear();
			Glib::RefPtr<Gtk::EntryCompletion> completion =  Gtk::EntryCompletion::create();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			completion->set_model(arvore_ref);
			CBRcolmeia.set_completion(completion);
			SQL.clear();
			SQL = "select id_col,data_form from cadastro.colmeias order by id_col";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			total=this->conexao->registros;
			if (total > 0)
				{
				this->conexao->resultado();
				for(ir=this->conexao->resultados.begin();ir<this->conexao->resultados.end();ir++)
					{
					linha = *ir;
					apiario.clear();
					celula = *(arvore_ref->append());
					celula[arvore_reg.reg] = atoi(linha.at(0).c_str());
					apiario= linha.at(0)+"  ";
					Aux.clear();
					Aux = linha.at(1);
					Data_formatada = new char[Aux.length()+1];	
					strcpy(Data_formatada,Aux.c_str());
					apiario+=data_formatada(Data_formatada, 2);
					delete Data_formatada;
					celula[arvore_reg.descricao]= apiario;
					}
				}
			else
				{
				celula = *(arvore_ref->append());
				celula[arvore_reg.reg] = 0;
				celula[arvore_reg.descricao]= "";
				}
			completion->set_text_column(arvore_reg.descricao);

			for(type_actions_map::iterator iter = m_CompletionActions.begin();iter != m_CompletionActions.end(); ++iter)
				{
				int position = iter->first;
				Glib::ustring title = iter->second;
				completion->insert_action_text(title, position);
				}
			if(this->visualizacaocolmeias==true)
				{
				dados.clear();
				dados = "select id_col,data_form from cadastro.abelha_rainha where rg="+this->id_selecionado;
				sqlar = new char[dados.length()+1];
				strcpy(sqlar,dados.c_str());
				this->conexao->executar(sqlar);
				delete sqlar;
				if (conexao->registros > 0)
					{
					this->conexao->resultado();
					ir = this->conexao->resultados.begin();
					linha = *ir;
					Aux.clear();
					Aux=linha.at(1);
					if(Aux.length()!=0)
						{
						colmeia = new char[Aux.length()+1];
						strcpy(colmeia,Aux.c_str());
						Aux.clear();
						Aux=linha.at(0);
						Aux+=" ";
						Aux+=data_formatada(colmeia, 2);
						CBRcolmeia.set_text(Aux);
						delete  colmeia;
						}
					else
						{
						CBRcolmeia.set_text(" ");
						}
					}
				else
					{
					CBRcolmeia.set_text(" ");	
					}
				}
			break;
			}
		case 10:
			{
			Glib::RefPtr<Gtk::EntryCompletion> completion =  Gtk::EntryCompletion::create();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			completion->set_model(arvore_ref);
			ent_ARloca.set_completion(completion);
			SQL.clear();
			SQL = "select id_api,nome,local,sub_regiao from cadastro.apiarios order by nome";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			total=this->conexao->registros;
			if (total > 0)
				{
				this->conexao->resultado();
				for(ir=this->conexao->resultados.begin();ir<this->conexao->resultados.end();ir++)
					{
					linha = *ir;
					apiario.clear();
					celula = *(arvore_ref->append());
					celula[arvore_reg.reg] = atoi(linha.at(0).c_str());
					apiario= linha.at(1)+"/"+linha.at(2)+"/"+linha.at(3)+"<"+linha.at(0)+">";
					celula[arvore_reg.descricao]= apiario;
					}
				}
			else
				{
				celula = *(arvore_ref->append());
				celula[arvore_reg.reg] = 0;
				celula[arvore_reg.descricao]= "";
				}
			completion->set_text_column(arvore_reg.descricao);

			for(type_actions_map::iterator iter = m_CompletionActions.begin();iter != m_CompletionActions.end(); ++iter)
				{
				int position = iter->first;
				Glib::ustring title = iter->second;
				completion->insert_action_text(title, position);
				}

			
			sprintf(cod_apiario,"%d",this->cod_apiarioar);
			dados.clear();
			dados = "select id_api,nome,local,sub_regiao from cadastro.apiarios where id_api=";
			dados.append(cod_apiario);
			sqlregiao = new char[dados.length()+1];
			strcpy(sqlregiao,dados.c_str());
		    this->conexao->executar(sqlregiao);
			delete sqlregiao;
			if (conexao->registros > 0)
				{
				this->conexao->resultado();
				ir = this->conexao->resultados.begin();
				linha = *ir;
				dados.clear();
				dados=linha.at(1)+" ; "+linha.at(2)+" ; "+linha.at(3);
				}
			else
				{
				dados.clear();
				dados = "";
				}
			this->ent_ARloca.set_text(dados);
			break;
			}
		default:
			{
			cout<<"Se isso aqui apareceu é pq deu pau!"<<endl;
			}
		}
	}
/**
 *
 */
void CADASTRO :: carregar_primeiro()
	{
	char *sql, *sql_aux, *aux, *aux_flag, *siglas, *siglas_aux, *bsc, *Data_formatada;
	int  pos_atual, contador, i,cod_aux,num_cid, num_flag;
	bool resposta; /**<para saber se o botão consultar achou o registro buscado.*/
	int arruma_codigo; /**<A base de dados é preenche com espaços vazios o cod da cidade, nesse colocaremos os espaços em branco*/
	int temp, temp2, temp3;
	bool teste_logico;

    string  Aux, SQL;
	
	string teste, buscar_registro;

	vector<vector<string> >::iterator ir;
	vector<string> linha;
	
	this->visualizacaosiglas=true;
	aux = new char [100];
	aux_flag= new char [100];
	siglas= new char [100];
	siglas_aux= new char [100];
	sql_aux= new char [100];
	this->id_selecionado.clear();
	resposta=false;
	switch (this->janela)
		{
		case 1:
			{
			cout << __LINE__ << ": Apiarios" << endl;
			this->tba_cancelar.set_sensitive (false);
			entNum.set_sensitive (false);
			entNome.set_sensitive (false);
			entSubreg.set_sensitive (false);
			entLoca.set_sensitive (false);
			entData.set_sensitive (false);
			ScrollObs.set_sensitive (false);
			CFlorada.set_sensitive(false);
			//entRegiao.set_sensitive(false);
			entRegiao.set_sensitive(false);
			BConsultar.set_sensitive(true);
			entCons.set_sensitive(true);
			ANavega.set_sensitive(true);
			//ANavega.set_sensitive(true);
			//ANavega.set_sensitive(true);
			//ANavega.set_sensitive(true);
			//ANavega.set_sensitive(true);

			tba_novo.set_sensitive (true);
			tba_alterar.set_sensitive (true);
			tba_salvar.set_sensitive (false);
			tba_excluir.set_sensitive (true);
			SQL.clear();
			SQL = "select * from cadastro.apiarios order by codigo";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			this->conexao->resultado();
			if (this->botao_consultar==true)
				{
				buscar_registro.clear();
				this->botao_consultar = false;
				buscar_registro = entCons.get_text();
				if(buscar_registro.length()==6)
					{					
					bsc = new char[buscar_registro.length()+1];
					}
				else
					{
					arruma_codigo = 7-buscar_registro.length();
					bsc = new char[buscar_registro.length()+arruma_codigo];	
					}
				strcpy(bsc,buscar_registro.c_str());
				for (i=0,ir=this->conexao->resultados.begin(); i < this->conexao->registros,ir < this->conexao->resultados.end(); i++, ir++)
					{
					linha = *ir;
					cout <<"teste"<<bsc<<"testando bsc e result"<<linha.at(1)<<"teste"<<endl;
					if (linha.at(1).compare(bsc)==0)
						{
						cout<<"To vindo aqui"<<endl;
					    this->posicao = i;
						resposta=true;
						break;
						}
					}
				if(resposta==false)
					{
					this->botao_consultar=false;
					Gtk::MessageDialog Aviso_Busca(Glib::ustring("Atenção"));
					Aviso_Busca.set_secondary_text(Glib::ustring("Registro não econtrado!"));
					Aviso_Busca.set_position(Gtk::WIN_POS_CENTER);
					Aviso_Busca.run();
					//this->posicao=0;
					//carregar_primeiro();
					}
				delete bsc;
				}
			cout << __FILE__ << ": " << __LINE__ << endl;
			linha = this->conexao->resultados.at(this->posicao);
			this->id_selecionado = linha.at(0);
			cout<<"\n\nTestando o numero do apiario "<<this->id_selecionado<<endl;
			//this->cod_apiario= this->resultado(this->posicao,0); coloquei porque achei q o id_selecionado não daria certo... mas se isso esta comentado é pq deu certo.
			this->entNome.set_text(linha.at(2)); //linha e coluna.
			this->cod_reg = atoi(linha.at(3).c_str());
			this->visualizacao=false;
			num_cid= atoi(linha.at(3).c_str());
			this->entSubreg.set_text(linha.at(4));
			this->entLoca.set_text(linha.at(5));
	
			Aux.clear();
			Aux = linha.at(6);
			if(Aux.length()>0)
				{
				Data_formatada = new char[Aux.length()+1];	
				strcpy(Data_formatada,Aux.c_str());
				cout<<Data_formatada<<endl;
				entData.set_text(data_formatada(Data_formatada, 2));
				delete Data_formatada;
				}
			else
				{
				this->entData.set_text(linha.at(6));
				}
			this->cod_florada = atoi(linha.at(7).c_str());
			this->PObs1 = this->TObs.get_buffer ();
			this->PObs1->set_text(linha.at(8));
			this->TObs.set_buffer(this->PObs1);
			this->entNum.set_alignment (Gtk::ALIGN_CENTER);
			this->entNum.set_text (Glib::ustring(linha.at(1)));
			//this->entNum.set_text(siglas);
			pos_atual=this->posicao;
			pos_atual=pos_atual+1;
			sprintf(aux,"Registro nº: %d / %d", pos_atual, this->total);
			this->entNav.set_text (Glib::ustring(aux));
			this->listagem_box(1);
			this->listagem_box(2);
			this->pagina=0;
			this->pagina_apicol=0;
			prepara_box_cliente();
			
			break;
			}
		case 2:
			{
			cout << __LINE__ << ": Colmeias" << endl;
			this->tbc_cancelar.set_sensitive (false);
			this->tbc_novo.set_sensitive(true);
			this->tbc_alterar.set_sensitive(true);
			this->tbc_excluir.set_sensitive(true);
			this->tbc_salvar.set_sensitive(false);
			
			CNavega.set_sensitive(true);
			CNavega.set_sensitive(true);
			CNavega.set_sensitive(true);
			CNavega.set_sensitive(true);
			CNavega.set_sensitive(true);
				
			entCcolmeia.set_sensitive (false);
			entCdatafor.set_sensitive (false);
			CTipo.set_sensitive (false);
			CAtividade.set_sensitive (false);
			entCbusca.set_sensitive(true);
			ColObs.set_editable(false);
			BCconsultar.set_sensitive(true);
			SQL.clear();
			SQL = "select * from cadastro.colmeias order by id_col";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (conexao->registros > 0)
				{
				this->conexao->resultado();
				if (this->botao_consultar==true)
					{
					i=0;
					this->botao_consultar = false;
					buscar_registro.clear();
					buscar_registro = entCbusca.get_text();
					temp=atoi(buscar_registro.c_str());
					ir = this->conexao->resultados.begin();
					while( ir < this->conexao->resultados.end())
						{
						linha = *ir;
						temp2=atoi(linha.at(0).c_str());
	
						if (temp==temp2)
							{
							temp3=atoi(linha.at(3).c_str());
							if(temp3!=0)
								{
								this->posicao = i;
								resposta=true;
								//teste_logico=false;
								}
							else
								{
								this->posicao = i;
								resposta=true;
								}
							break;
							}
						i++;
						}
					if(resposta==false)
						{
						this->botao_consultar=false;
						Gtk::MessageDialog Aviso_Busca(Glib::ustring("Atenção"), false);
						Aviso_Busca.set_secondary_text(Glib::ustring("Registro não econtrado!"));
						Aviso_Busca.set_position(Gtk::WIN_POS_CENTER);
						Aviso_Busca.run();
						
						}
					}
				BCconsultar.set_sensitive(true);
				linha = this->conexao->resultados.at(this->posicao);
				this->id_selecionado = linha.at(0);
				this->entCcolmeia.set_text(linha.at(0)); //linha e coluna.
			

				Aux.clear();
				Aux = linha.at(1);
				Data_formatada = new char[Aux.length()+1];	
				strcpy(Data_formatada,Aux.c_str());
				entCdatafor.set_text(data_formatada(Data_formatada, 2));
			
				delete Data_formatada;
				//this->entCdatafor.set_text(this->resultado(this->posicao,1));
				this->cod_tp = atoi(linha.at(2).c_str());
				this->cod_st = atoi(linha.at(3).c_str());

				PObs4 = ColObs.get_buffer ();
				PObs4->get_bounds (inicial,final);
				iter = PObs4->erase (inicial,final);
				PObs4->insert(iter,Glib::ustring(linha.at(6)));
				cout << __FILE__ << " :"<< __LINE__ << endl;				
				ColObs.set_buffer(PObs4);
				pos_atual=this->posicao;
				pos_atual=pos_atual+1;
				sprintf(aux,"Registro nº: %d / %d", pos_atual, this->total);
				this->entNavcolmeias.set_text (Glib::ustring(aux));
				}
			else
				{
				id_selecionado = "0";
				pos_atual=0;
				pos_atual=0;
				sprintf(aux,"Registro nº: %d / %d", pos_atual, this->total);
				this->entNavcolmeias.set_text (Glib::ustring(aux));
				}
			this->listagem_box(3);
			this->listagem_box(4);
			break;
			}//fim case 2
		case 3:
			{
			cout << __LINE__ << ": Planilhas" << endl;
			cout << this->posicao << endl;
			entPnum.set_sensitive (false);
			entPdata.set_sensitive (false);
			entPhrini.set_sensitive (false);
			entPhrfim.set_sensitive (false);
			CBPTipo.set_sensitive (false);
			entPApiario.set_sensitive (false);
			ScrollPlanObs.set_sensitive (false);
			entPplannum.set_sensitive (true);
			PNavega.set_sensitive(true);

			BPconsultar.set_sensitive(true);
			this->tbp_cancelar.set_sensitive (false);
			this->tbp_novo.set_sensitive (true);
			this->tbp_alterar.set_sensitive (true);
			this->tbp_excluir.set_sensitive (true);
			this->tbp_salvar.set_sensitive (false);
			this->tbp_imprimir.set_sensitive(true);
			SQL.clear();
			SQL = "select * from cadastro.planilhas order by nump";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (conexao->query_result != 3)
				{
				total = conexao->registros;
				if (total > 0)
					{
					this->conexao->resultado();
					if (this->botao_consultar==true)
						{
						this->botao_consultar=false;
						buscar_registro = entPplannum.get_text();
						bsc = new char[buscar_registro.length()+1];
						strcpy(bsc,buscar_registro.c_str());
						//cout<<"Entrei dentro do if"<<bsc<<endl;
						for (i=0, ir=this->conexao->resultados.begin(); i < this->conexao->registros,ir < this->conexao->resultados.end(); i++,ir++)
							{
							linha = *ir;
							//cout<<"Valor do registro na posicao i"<<this->resultado(i,0)<<" "<<i<<endl;
							if (linha.at(0).compare(bsc) == 0)
								{
								this->posicao = i; // terminar o tratamento da busca
								resposta=true;
								break;
								}
							}
						if(resposta==false)
							{
							this->botao_consultar=false;
							Gtk::MessageDialog Aviso_Busca(Glib::ustring("Atenção"), false);
							Aviso_Busca.set_secondary_text(Glib::ustring("Registro não econtrado!"));
							Aviso_Busca.set_position(Gtk::WIN_POS_CENTER);
							Aviso_Busca.run();
							//this->posicao=0;
							//carregar_primeiro();
							}
						delete bsc;
						}
					linha = this->conexao->resultados.at(this->posicao);
					this->id_selecionado = linha.at(0);
					this->entPnum.set_text(linha.at(0));

					Aux.clear();
					Aux = linha.at(1);
					Data_formatada = new char[Aux.length()+1];	
					strcpy(Data_formatada,Aux.c_str());
					entPdata.set_text(data_formatada(Data_formatada, 2));
					delete Data_formatada;
			
					//this->entPdata.set_text(this->resultado(this->posicao,1)); //linha e coluna.
				//	this->entPhrini.set_text(this->resultado(this->posicao,2));
				//	this->entPhrfim.set_text(this->resultado(this->posicao,3));
					this->tipo_planilha = atoi(linha.at(7).c_str());
					this->cod_api = atoi(linha.at(5).c_str());
					sprintf(cod_apiario,"%d",this->cod_api);
					this->PObs2 = this->PlanObs.get_buffer ();
					this->PObs2->set_text(linha.at(6));
					this->PlanObs.set_buffer(this->PObs2);
					pos_atual=this->posicao;
					pos_atual=pos_atual+1;
					sprintf(aux,"Registro nº: %d / %d", pos_atual, this->total);
					this->entNavplanilhas.set_text (Glib::ustring(aux));
					}
				else
					{
					id_selecionado = "0";
					pos_atual=0;
					pos_atual=0;
					sprintf(aux,"Registro nº: %d / %d", pos_atual, this->total);
					this->entNavcolmeias.set_text (Glib::ustring(aux));
					}
				}
			this->listagem_box(5);
			this->listagem_box(6);
			break;
			}//fim case 3
		case 5:
			{
			cout << __FILE__ << ": Siglas" << endl;
			this->tbs_salvar.set_sensitive (false);
			this->tbs_excluir.set_sensitive (true);
			this->tbs_alterar.set_sensitive (true);
			this->tbs_novo.set_sensitive (true);
			this->tbs_cancelar.set_sensitive (false);

			SNavega.set_sensitive(true);
			SNavega.set_sensitive(true);
			SNavega.set_sensitive(true);
			SNavega.set_sensitive(true);
			SNavega.set_sensitive(true);

			entSiglas.set_sensitive (false);
			entSiglasPreencher.set_sensitive (false);
				
			this->controle=2;
			SQL.clear();
			SQL = "select * from cadastro.siglas order by cod_cid";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			this->conexao->resultado();
			linha = this->conexao->resultados.at(this->posicao);
			this->entSiglas.set_text(linha.at(0));
			this->cod_reg = atoi(linha.at(1).c_str());
			this->listagem_box(7);
			pos_atual=this->posicao;
			pos_atual=pos_atual+1;
			sprintf(aux,"Registro nº: %d / %d", pos_atual, this->total);
			this->entNavsiglas.set_text (Glib::ustring(aux));
			break;
			}
		case 6:
			{
			cout << __LINE__ << ":Abelha Rainha" << endl;
			this->tbar_salvar.set_sensitive (false);
			this->tbar_excluir.set_sensitive (true);
			this->tbar_alterar.set_sensitive (true);
			this->tbar_novo.set_sensitive (true);
			this->tbar_cancelar.set_sensitive (false);

			ARNavega.set_sensitive(true);
			entarrg.set_sensitive (false);
			entarcodatual.set_sensitive (false);
			entarcodnovo.set_sensitive (false);
			entardatanas.set_sensitive (false);
			entardatafec.set_sensitive (false);

			entargera.set_sensitive (false);
			entarrgmae.set_sensitive (false);
			CBRainha.set_sensitive (false);
			CBRcolmeia.set_sensitive (false);
			ScrollarObs.set_sensitive (false);
			entarconsultar.set_sensitive (true);
			this->tbar_cancelar.set_sensitive (false);
			SQL.clear();
			SQL = "select * from cadastro.abelha_rainha order by rg";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (conexao->registros > 0)
				{
				this->conexao->resultado();
				if (this->botao_consultar==true)
					{
					//this->id_colm;	
					this->botao_consultar = false;
					buscar_registro = entarconsultar.get_text();
					bsc = new char[buscar_registro.length()+1];
					strcpy(bsc,buscar_registro.c_str());
					for (i=0,ir=this->conexao->resultados.begin(); i < this->conexao->registros,ir < this->conexao->resultados.end(); i++,ir++)
						{
						linha = *ir;
						//cout << this->resultado(i,0);
						if (linha.at(0).compare(bsc) == 0)
							{
							this->posicao = i;
							resposta=true;
							break;
							}
						}
					if(resposta==false)
						{
						this->botao_consultar=false;
						Gtk::MessageDialog Aviso_Busca(Glib::ustring("Atenção"), false);
						Aviso_Busca.set_secondary_text(Glib::ustring("Registro não econtrado!"));
						Aviso_Busca.set_position(Gtk::WIN_POS_CENTER);
						Aviso_Busca.run();
						//this->posicao=0;
						//carregar_primeiro();
						}
					delete bsc;
					}
				linha = this->conexao->resultados.at(this->posicao);
				this->id_selecionado = linha.at(0);
				//cout<<this->id_selecionado<<endl;
				this->entarrg.set_text(linha.at(0));
				this->entarcodatual.set_text(linha.at(1));
				this->entarcodnovo.set_text(linha.at(2));
				Aux.clear();
				if(linha.at(3).length()>0)
					{
					Aux = linha.at(3);
					Data_formatada = new char[Aux.length()+1];	
					strcpy(Data_formatada,Aux.c_str());
					this->entardatanas.set_text(data_formatada(Data_formatada, 2));
					delete Data_formatada;
					}
				else
					{
					this->entardatanas.set_text("");	
					}
				Aux.clear();
				if(linha.at(4).length()>0)
					{
					Aux = linha.at(4);
					Data_formatada = new char[Aux.length()+1];	
					strcpy(Data_formatada,Aux.c_str());
					this->entardatafec.set_text(data_formatada(Data_formatada, 2));
					delete Data_formatada;
					}
				else
					{
					this->entardatafec.set_text("");
					}

				Aux.clear();
							
				this->entargera.set_text(linha.at(5));
				this->PObs3 = this->RainhaObs.get_buffer ();
				this->PObs3->set_text(linha.at(6));
				this->RainhaObs.set_buffer(this->PObs3);

				if(atoi(linha.at(9).c_str()) == 0)
					{
					cod_abelha=0;
					}
				else
					{
					this->cod_abelha = atoi(linha.at(9).c_str());
					}
				//this->entarrgmae.set_text(this->resultado(this->posicao,8)); //entry do rg da mae antes de colocar combox
				this->id_col=atoi(linha.at(7).c_str());
		
				this->data_form = linha.at(8);
				this->cod_apiarioar = atoi(linha.at(10).c_str());
				pos_atual=this->posicao;
				pos_atual=pos_atual+1;
				sprintf(aux,"Registro nº: %d / %d", pos_atual, this->total);
				this->entNavrainhas.set_text (Glib::ustring(aux));
				}
			else
				{
				id_selecionado = "0";
				pos_atual=0;
				pos_atual=0;
				sprintf(aux,"Registro nº: %d / %d", pos_atual, this->total);
				this->entNavrainhas.set_text (Glib::ustring(aux));
				}
			this->listagem_box(8);
			this->listagem_box(9);
			this->listagem_box(10);
			break;
			}
		}
	}

/**
 *
 */
void CADASTRO:: contar_dados()
	{
	string SQL;
	char *sql;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	this->posicao=0;
	switch (this->janela)
		{
		case 1:
			{
			SQL.clear();
			SQL = "select count(*) from cadastro.apiarios";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			this->conexao->resultado();
			linha = this->conexao->resultados.at(0);
			this->total= atoi(linha.at(0).c_str());
			break;
			}
		case 2:
			{
			SQL.clear();
			SQL = "select count(*) from cadastro.colmeias";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			this->conexao->resultado();
			linha = this->conexao->resultados.at(0);
			this->total= atoi(linha.at(0).c_str());
			break;
			}
		case 3:
			{
			SQL.clear();
			SQL = "select count(*) from cadastro.planilhas";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			this->conexao->resultado();
			linha = this->conexao->resultados.at(0);
			this->total= atoi(linha.at(0).c_str());
			break;
			}
		case 5:
			{
			SQL.clear();
			SQL = "select count(*) from cadastro.siglas";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			this->conexao->resultado();
			linha = this->conexao->resultados.at(0);
			this->total= atoi(linha.at(0).c_str());
			break;
			}
		case 6:
			{
			SQL.clear();
			SQL = "select count(*) from cadastro.abelha_rainha";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			this->conexao->resultado();
			linha = this->conexao->resultados.at(0);
			this->total= atoi(linha.at(0).c_str());
			break;
			}
		}
	}

/**
 *
 */
void CADASTRO::troca_pagina(int opcao)
	{
	int erro = 0;
	
	switch(opcao)
		{
		case 1:
			{
			if (this->posicao== 0)
				{
				Gtk::MessageDialog Aviso_Pagina(Glib::ustring("Atenção"), false);
				Aviso_Pagina.set_secondary_text(Glib::ustring("Você já está na primeira pagina!"));
				Aviso_Pagina.set_position(Gtk::WIN_POS_CENTER);
				Aviso_Pagina.run();
				++erro;
				}
			else
				{
				this->posicao=0;
				}
			//era antes else ++erro
			break;
			}
		case 2:
			{
			if (this->posicao > 0)// && this->posicao > (this->total+1))
				{
				this->posicao--;
				}
			else
				{
				Gtk::MessageDialog Aviso_Pagina(Glib::ustring("Atenção"), false);
				Aviso_Pagina.set_secondary_text(Glib::ustring("Você já está na primeira pagina!"));
				Aviso_Pagina.set_position(Gtk::WIN_POS_CENTER);
				Aviso_Pagina.run();
				++erro;
				}
			//era antes else ++erro
			break;
			}
		case 3:
			{
			if (this->total > 0 && this->posicao < (this->total-1))
				{
				this->posicao++;
				}
			else
				{
				Gtk::MessageDialog Aviso_Pagina(Glib::ustring("Atenção"), false);
				Aviso_Pagina.set_secondary_text(Glib::ustring("Você já está na ultima página!"));
				Aviso_Pagina.set_position(Gtk::WIN_POS_CENTER);
				Aviso_Pagina.run();
				++erro;
				}
			//era antes else ++erro
			break;
			}
		case 4:
			{
			if (this->total > 0 && this->posicao < (this->total-1))
				{
				this->posicao = (this->total-1);  //tava antes this->posicao = (this->total-1)
				}
			else
				{
				Gtk::MessageDialog Aviso_Pagina(Glib::ustring("Atenção"), false);
				Aviso_Pagina.set_secondary_text(Glib::ustring("Você já está na ultima página!"));
				Aviso_Pagina.set_position(Gtk::WIN_POS_CENTER);
				Aviso_Pagina.run();
				++erro;
				}
			//era antes else
			break;
			}
		}
	if(!erro)
		{
		this->carregar_primeiro();
		}
	}

/**
 * Cadastramento do sistema
 */
void CADASTRO :: novo()
	{
	char *sql, *sqlaux, *aux, *Data_formatada;
	string var_aux, SQL, Data_hoje;
	int i,j, auxid_col, auxstatus, auxflag, aux_plan;
	vector<string> linha;
	
	switch (this->janela)
		{
		case 1:
			{
			this->tba_salvar.set_sensitive (true);
			this->tba_excluir.set_sensitive (false);
			this->tba_alterar.set_sensitive (false);
			this->tba_novo.set_sensitive (false);
			this->tba_cancelar.set_sensitive (true);
			this->visualizacao=false;
			entNum.set_sensitive (false);
			entNome.set_sensitive (true);
			entSubreg.set_sensitive (true);
			entLoca.set_sensitive (true);
			entData.set_sensitive (true);
			ScrollObs.set_sensitive (true);
			entCons.set_sensitive (false);
			CFlorada.set_sensitive (true);
			entRegiao.set_sensitive(true);
			
			BConsultar.set_sensitive(false);
			ANavega.set_sensitive(false);
			ANavega.set_sensitive(false);
			ANavega.set_sensitive(false);
			ANavega.set_sensitive(false);
			ANavega.set_sensitive(false);
			this->entNum.set_text("");
			this->entNome.set_text("");
			this->entRegiao.set_text("");
			//this->cod_reg = 5003702;//para começar setado em Dourados
			//gerar_codigo();
			//this->cod_reg=0;
			this->entSubreg.set_text("");
			this->entLoca.set_text("");
			this->entData.set_text("");
			this->cod_florada = 1;
			this->PObs1 = Gtk::TextBuffer::create ();
			this->PObs1->set_text("");
			this->TObs.set_buffer(this->PObs1);
			this->Apiarios.set_focus(this->entNome);
			break;
			}
		case 2:
			{
			this->tbc_novo.set_sensitive (false);
			this->tbc_salvar.set_sensitive (true);
			this->tbc_alterar.set_sensitive (false);
			this->tbc_cancelar.set_sensitive (true);

			BCconsultar.set_sensitive(false);
			
			entCcolmeia.set_sensitive (false);
			entCdatafor.set_sensitive (true);
			CTipo.set_sensitive (true);
			entCbusca.set_sensitive(false);
			CAtividade.set_sensitive (true);
			PObs4 = ColObs.get_buffer ();
			PObs4->get_bounds (inicial,final);
			iter = PObs4->erase (inicial,final);
			//PObs4->insert(iter,Glib::ustring(linha.at(6));
			ColObs.set_buffer (PObs4);
			ColObs.set_editable (true);
				
			CNavega.set_sensitive(false);
			CNavega.set_sensitive(false);
			CNavega.set_sensitive(false);
			CNavega.set_sensitive(false);
			CNavega.set_sensitive(false);

			this->entCdatafor.set_text("");
			this->entCcolmeia.set_text("");
			this->cod_tp =1;
			this->cod_st =1;

			this->Colmeias->set_focus(this->entCdatafor);

			break;
			}
		case 3:
			{
			this->tbp_salvar.set_sensitive (true);
			this->tbp_excluir.set_sensitive (false);
			this->tbp_alterar.set_sensitive (false);
			this->tbp_novo.set_sensitive (false);
			this->tbp_cancelar.set_sensitive (true);
			this->tbp_imprimir.set_sensitive(false);

			entPnum.set_sensitive (false);
			entPdata.set_sensitive (true);
			entPhrini.set_sensitive (true);
			entPhrfim.set_sensitive (true);
			ScrollPlanObs.set_sensitive (true);
			CBPTipo.set_sensitive (true);
			entPApiario.set_sensitive(true);
			entPplannum.set_sensitive(false);
			BPconsultar.set_sensitive(false);
			this->Planilhas->set_focus(this->entPdata);

			PNavega.set_sensitive(false);
			PNavega.set_sensitive(false);
			PNavega.set_sensitive(false);
			PNavega.set_sensitive(false);
			PNavega.set_sensitive(false);
			SQL.clear();
			SQL = "select nump from cadastro.planilhas order by nump desc limit 1 offset 0";
			sql = new char[SQL.length()+1];
			strcpy(sql, SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (conexao->registros > 0)
				{
				this->conexao->resultado();
				linha = this->conexao->resultados.at(0);
				aux_plan=atoi(linha.at(0).c_str());
				aux_plan+=1;
				}
			else
				{
				aux_plan = 1;
				}
			aux = new char[32];
			sprintf(aux,"%d",aux_plan);
			this->entPnum.set_text(aux);
			delete aux;
			this->entPdata.set_text("");
			this->entPApiario.set_text("");
			this->entPhrini.set_text("");
			this->entPhrfim.set_text("");
			this->tipo_planilha = 2;
			this->cod_api = 1;
			this->PObs2 = Gtk::TextBuffer::create ();
			this->PObs2->set_text("");
			this->PlanObs.set_buffer(this->PObs2);
			this->Planilhas->set_focus(this->entPdata);
			Data_formatada = new char [11];
			Data_formatada = hoje();
	
			Data_hoje.clear();
			Data_hoje.append(data_formatada(Data_formatada, 2));
		
			this->entPdata.set_text(Data_hoje);
			delete Data_formatada;
			break;
			}
		case 5:
			{
			this->tbs_salvar.set_sensitive (true);
			this->tbs_excluir.set_sensitive (false);
			this->tbs_alterar.set_sensitive (false);
			this->tbs_novo.set_sensitive (false);
			this->tbs_cancelar.set_sensitive (true);
			this->visualizacaosiglas=false;
			
			entSiglas.set_sensitive (true);
			entSiglasPreencher.set_sensitive (true);
			CNavega.set_sensitive(false);
			CNavega.set_sensitive(false);
			CNavega.set_sensitive(false);
			CNavega.set_sensitive(false);
			CNavega.set_sensitive(false);
			this->controle=1;
			this->entSiglasPreencher.set_text("");
			this->entSiglas.set_text("");
			this->Siglas.set_focus(this->entSiglasPreencher);
			this->listagem_box(7);
			break;
			}
		case 6:
			{
			if(this->acao_abelha==1)
				{
				this->Abelha_Rainha->set_focus(this->entardatanas);
				this->acao_abelha=0;
				}
			else
				{
				this->tbar_salvar.set_sensitive (true);
				this->tbar_excluir.set_sensitive (false);
				this->tbar_alterar.set_sensitive (false);
				this->tbar_novo.set_sensitive (false);
				this->tbar_cancelar.set_sensitive (true);

				entarrg.set_sensitive (false);
				entarcodatual.set_sensitive (true);
				entarcodnovo.set_sensitive (false);
				entardatanas.set_sensitive (true);
				entardatafec.set_sensitive (true);
				entardatarev.set_sensitive (true);
				entargera.set_sensitive (true);
				CBRainha.set_sensitive (true);
				CBRcolmeia.set_sensitive (true);
				ScrollarObs.set_sensitive (true);
				entarconsultar.set_sensitive (false);
				ent_ARloca.set_sensitive(true);
				this->Abelha_Rainha->set_focus(this->entarcodatual);

				ARNavega.set_sensitive(false);

				this->visualizacaocolmeias=false;
				entarrg.set_text("");
				entarcodatual.set_text("");
				entarcodnovo.set_text("");
				entardatanas.set_text("");
				entardatafec.set_text("");
				ent_ARloca.set_text("");
				entargera.set_text("");
				CBRcolmeia.set_text("");
				listagem_box(8);
				entarconsultar.set_text("");
				this->PObs3 = Gtk::TextBuffer::create ();
				this->PObs3->set_text("");
				this->RainhaObs.set_buffer(this->PObs3);
				}
			break;
			}
		}
	this->acao=1;
	}

/**
 *
 */
void CADASTRO::editar_registro()
	{
	switch (this->janela)
		{
		case 1:
			{
			this->tba_salvar.set_sensitive (true);
			this->tba_excluir.set_sensitive (false);
			this->tba_alterar.set_sensitive (false);
			this->tba_novo.set_sensitive (false);
			this->tba_cancelar.set_sensitive (true);

			entNum.set_sensitive (false);
			entNome.set_sensitive (true);
			entSubreg.set_sensitive (true);
			BConsultar.set_sensitive(true);
			entLoca.set_sensitive (true);
			entData.set_sensitive (true);
			ScrollObs.set_sensitive (true);
			entCons.set_sensitive (false);
			CFlorada.set_sensitive (true);
			entRegiao.set_sensitive(false);
			ANavega.set_sensitive(false);
			ANavega.set_sensitive(false);
			ANavega.set_sensitive(false);
			ANavega.set_sensitive(false);
			ANavega.set_sensitive(false);
			BConsultar.set_sensitive(true);
			break;
			}
		case 2:
			{
			//bool decisao;
			if(this->cod_st == 0)
				{
				Gtk::MessageDialog Erro(Glib::ustring("Erro"));
				Erro.set_secondary_text("Registro não pode ser editado pois se encontra Inativo.");
				Erro.set_position(Gtk::WIN_POS_CENTER);
				Erro.run();
				this->tbc_alterar.set_sensitive (false);
				}
			else
				{
				this->tbc_novo.set_sensitive (false);
				this->tbc_salvar.set_sensitive (true);
				this->tbc_alterar.set_sensitive (false);
				this->tbc_cancelar.set_sensitive (true);
								
				BCconsultar.set_sensitive(true);

				entCcolmeia.set_sensitive (false);
				entCdatafor.set_sensitive (false);
				entCbusca.set_sensitive(false);
				CTipo.set_sensitive (true);
				CAtividade.set_sensitive (true);
				ColObs.set_editable (true);
				CNavega.set_sensitive(false);
				CNavega.set_sensitive(false);
				CNavega.set_sensitive(false);
				CNavega.set_sensitive(false);
				CNavega.set_sensitive(false);
				}

			break;
			}
		case 3:
			{
			this->tbp_salvar.set_sensitive (true);
			this->tbp_excluir.set_sensitive (false);
			this->tbp_alterar.set_sensitive (false);
			this->tbp_novo.set_sensitive (false);
			this->tbp_cancelar.set_sensitive (true);
			entPplannum.set_sensitive(false);
			BPconsultar.set_sensitive(false);

			entPnum.set_sensitive (true);
			entPdata.set_sensitive (true);
			entPhrini.set_sensitive (true);
			entPhrfim.set_sensitive (true);
			ScrollPlanObs.set_sensitive (true);
			CBPTipo.set_sensitive (true);
			entPApiario.set_sensitive(true);
			PNavega.set_sensitive(false);
			PNavega.set_sensitive(false);
			PNavega.set_sensitive(false);
			PNavega.set_sensitive(false);
			PNavega.set_sensitive(false);

			break;
			}
		case 5:
			{
			this->tbs_salvar.set_sensitive (true);
			this->tbs_excluir.set_sensitive (false);
			this->tbs_alterar.set_sensitive (false);
			this->tbs_novo.set_sensitive (false);
			this->tbs_cancelar.set_sensitive (true);

			entSiglas.set_sensitive (true);
			entSiglasPreencher.set_sensitive (false);
			SNavega.set_sensitive(false);
			SNavega.set_sensitive(false);
			SNavega.set_sensitive(false);
			SNavega.set_sensitive(false);
			SNavega.set_sensitive(false);
			break;
			}
		case 6:
			{
			if(this->acao_abelha==1)
				{
				this->Abelha_Rainha->set_focus(this->entardatanas);
				this->acao_abelha=0;
				}
			else
				{
				this->tbar_salvar.set_sensitive (true);
				this->tbar_excluir.set_sensitive (false);
				this->tbar_alterar.set_sensitive (false);
				this->tbar_novo.set_sensitive (false);
				this->tbar_cancelar.set_sensitive (true);

				entarrg.set_sensitive (false);
				entarcodatual.set_sensitive (true);
				entarcodnovo.set_sensitive (false);
				entardatanas.set_sensitive (true);
				entardatafec.set_sensitive (true);
				entardatarev.set_sensitive (true);
				entargera.set_sensitive (true);
				CBRainha.set_sensitive (true);
				CBRcolmeia.set_sensitive (true);
				ScrollarObs.set_sensitive (true);
				entarconsultar.set_sensitive (false);
				this->Abelha_Rainha->set_focus(this->entarcodatual);

				ARNavega.set_sensitive(false);
				ARNavega.set_sensitive(false);
				ARNavega.set_sensitive(false);
				ARNavega.set_sensitive(false);
				ARNavega.set_sensitive(false);
				}
			break;
			}
		}

	this->acao=2;
	}

/**
 * Salvar registro
 */
void CADASTRO :: armazenar_registro()
	{
	char *sql,*sqlaux, *aux, *Data_formatada;
	int pos_atual, i, j, auxid_col, auxstatus,result, col_num;
	bool resposta;
	string var_aux, cidade, SQL, AUX, var_aux2;
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	ofstream arq_log;
	string log;
	
	var_aux.clear();
	switch (this->acao) //para saber se vai salvar um novo registrou ou se vai salvar o registro editado.
		{
		case 1:
			{
			switch (this->janela)
				{
				case 1:
					{
					this->tba_salvar.set_sensitive (false);
					this->tba_excluir.set_sensitive (true);
					this->tba_alterar.set_sensitive (true);
					this->tba_novo.set_sensitive (true);
					this->tba_cancelar.set_sensitive (false);

					entNum.set_sensitive (false);
					entNome.set_sensitive (false);
					entSubreg.set_sensitive (false);
					entLoca.set_sensitive (false);
					entData.set_sensitive (false);
					ScrollObs.set_sensitive (false);
					entCons.set_sensitive (false);
					CFlorada.set_sensitive(false);
					entRegiao.set_sensitive(false);
					entCons.set_sensitive(true);

					ANavega.set_sensitive(true);
					ANavega.set_sensitive(true);
					ANavega.set_sensitive(true);
					ANavega.set_sensitive(true);
					ANavega.set_sensitive(true);
					
					if(entNum.get_text_length() >0)
						{
						SQL.clear();
						SQL = "insert into cadastro.apiarios (nome, codigo,cod_cid,sub_regiao,local,data,id_flor,obs,flag) values ('";
						SQL += this->entNome.get_text();
						SQL += "','";
						SQL += this->entNum.get_text();
						SQL += "',";
						var_aux.clear();
						cidade.clear();
						cidade=entRegiao.get_text();
						var_aux="select cod_cid from cadastro.municipio where estado='MS' and nome='"+cidade+"'";
						sqlaux = new char[var_aux.length()+1];
						strcpy(sqlaux,var_aux.c_str());
						this->conexao->executar(sqlaux);
						delete sqlaux;
						this->conexao->resultado();
						linha = this->conexao->resultados.at(0);
						SQL += linha.at(0);
						SQL += ",'";
						SQL += this->entSubreg.get_text();
						SQL += "','";
						SQL += this->entLoca.get_text();
						SQL += "',";

						if(this->entData.get_text_length() == 10)
							{
							SQL += "'";
							var_aux.clear();
							var_aux = this->entData.get_text();
							Data_formatada = new char[var_aux.length()+1];	
							strcpy(Data_formatada,var_aux.c_str());
							var_aux = data_formatada(Data_formatada, 1);
							delete Data_formatada;
							SQL += var_aux + "',";
							}
						else
							{
							SQL += "null,";
							}

						contador = this->CFlorada.get_active();
						if(contador)
							{
							registro=*contador;
							if(registro)
								{
								this->cod_florada=registro[arvore_reg.reg];
								}
							}
						aux = new char[32];
						sprintf (aux,"%d",this->cod_florada);
						SQL.append(aux);
						delete aux;
						SQL += ",'";
						this->PObs1 = Gtk::TextBuffer::create ();
						this->PObs1 = TObs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
						var_aux.clear();
						var_aux= this->PObs1->get_text();
						SQL += var_aux;
						SQL += "',";
						aux = new char[32];
						sprintf (aux,"%d",flag);
						SQL.append(aux);
						SQL += ")";
						sql = new char [SQL.length()+1];
						strcpy(sql,SQL.c_str());
						this->conexao->executar(sql);
						this->total=this->total+1;
						this->posicao=0;
						//this->carregar_primeiro();
						}
					else
						{
						Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
						Confirma.set_secondary_text("Preencha a cidade de forma correta!");
						Confirma.set_position(Gtk::WIN_POS_CENTER);
						Confirma.run();
						}
					break;
					}
				case 2:
					{
					arq_log.open("log.txt");
					log.clear();
					this->tbc_salvar.set_sensitive (false);
					this->tbc_alterar.set_sensitive (true);
					this->tbc_novo.set_sensitive (true);
					this->tbc_cancelar.set_sensitive (false);

					entCcolmeia.set_sensitive(false);
					entCdatafor.set_sensitive(false);
					CTipo.set_sensitive(false);
					CAtividade.set_sensitive(false);
					ColObs.set_editable(false);
					CNavega.set_sensitive(true);
					CNavega.set_sensitive(true);
					CNavega.set_sensitive(true);
					CNavega.set_sensitive(true);
					CNavega.set_sensitive(true);
						
					arq_log << __FILE__ << " :" << __LINE__ << endl;
					cout << __FILE__ << ":" << __LINE__ << endl;
					SQL.clear();
					SQL = "insert into cadastro.colmeias (id_col,data_form,tipo,status, obs) values (nextval('cadastro.cod_new_colmeia'),'";
					SQL += this->entCdatafor.get_text();
					SQL += "',";
					contador = this->CTipo.get_active();
					if(contador)
						{
						registro=*contador;
						if(registro)
							{
							this->cod_tp=registro[arvore_reg.reg];
							}
						}
					aux = new char[32];
					sprintf(aux,"%d",this->cod_tp);
					SQL.append(aux);
					delete aux;
					SQL += ",";
					contador = this->CAtividade.get_active();
					if(contador)
						{
						registro=*contador;
						if(registro)
							{
							this->cod_st=registro[arvore_reg.reg];
							}
						}
					aux = new char[32];
					sprintf(aux,"%d",this->cod_st);
					SQL.append(aux);
					SQL += ",'";
					delete aux;
					//PObs4 = Gtk::TextBuffer::create ();
					PObs4 = ColObs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
					var_aux.clear();
					var_aux= PObs4->get_text();
					SQL += var_aux;
					SQL += "') returning id_col;";
					
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					arq_log << sql << endl;
					this->conexao->executar(sql);
					delete sql;
					if (this->conexao->query_result != 3)
						{
						this->conexao->resultado();
						vector<string> linha;
						linha = this->conexao->resultados.at(0);
						this->entCcolmeia.set_text(linha.at(0));
						this->total=this->total+1;
						}
					else
						{
						arq_log << this->conexao->mensagem << endl;
						}
					this->posicao=0;
					arq_log.close();
					cout << __FILE__ << ":" << __LINE__ << endl;
					this->carregar_primeiro();
					break;
					}
				case 3:
					{
					this->tbp_salvar.set_sensitive (false);
					this->tbp_excluir.set_sensitive (true);
					this->tbp_alterar.set_sensitive (true);
					this->tbp_novo.set_sensitive (true);
					this->tbp_cancelar.set_sensitive (false);
					this->tbp_imprimir.set_sensitive(true);

					entPnum.set_sensitive (false);
					entPdata.set_sensitive (false);
					entPhrini.set_sensitive (false);
					entPhrfim.set_sensitive (false);
					CBPTipo.set_sensitive (false);
					entPApiario.set_sensitive (false);
					ScrollPlanObs.set_sensitive (false);
					entPplannum.set_sensitive (false);
					if(this->entPdata.get_text_length()!=0) //Coloquei o tratamento apenas para ter uma condição
						{
						SQL.clear();
						SQL = "insert into cadastro.planilhas (nump,data,horai,horaf,tipo,apiario,obs) values (";
						SQL += this->entPnum.get_text();
						SQL += ",";
						if(this->entPdata.get_text_length() == 10)
							{
							SQL += "'";
							SQL += this->entPdata.get_text();
							SQL += "',";
							}
						else
							{
							SQL += "null,";
							}

						if(this->entPhrini.get_text_length() == 5)
							{
							SQL += "'";
							SQL += this->entPhrini.get_text();
							SQL += "',";
							}
						else
							{
							SQL += "null,";
							}

						if(this->entPhrfim.get_text_length() == 5)
							{
							SQL += "'";
							SQL += this->entPhrfim.get_text();
							SQL += "',";
							}
						else
							{
							SQL += "null,";
							}

						contador = this->CBPTipo.get_active();
						if(contador)
							{
							registro=*contador;
							if(registro)
								{
								this->tipo_planilha=registro[arvore_reg.reg];
								}
							}
						aux = new char[32];
						sprintf(aux,"%d",this->tipo_planilha);
						SQL.append(aux);
						delete aux;
						SQL += ",";
	//**************************************************************************************
						string auxiliaridapi;
						int i,j, cont;
						auxiliaridapi.clear();
						auxiliaridapi = entPApiario.get_text();
						i = auxiliaridapi.find('<');
						if (i != string::npos)
							{
							j = auxiliaridapi.find('>');
							}
						SQL += auxiliaridapi.substr(i+1,j-i-1);
											
	//*************************************************************************
						SQL += ",'";
						this->PObs2 = Gtk::TextBuffer::create ();
						this->PObs2 = PlanObs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
						SQL += this->PObs2->get_text();
						SQL += "')";
						sql = new char[SQL.length()+1];
						strcpy(sql,SQL.c_str());
						this->conexao->executar(sql);
						this->total=this->total+1;
						this->posicao=0;
						this->carregar_primeiro();
						//cout<<(Glib::ustring(sql))<<endl;
						}
					else
						{
						cout<<"Dados invalidos"<<endl;
						}
					PNavega.set_sensitive(true);
					PNavega.set_sensitive(true);
					PNavega.set_sensitive(true);
					PNavega.set_sensitive(true);
					PNavega.set_sensitive(true);

					break;
					}
				case 5:
					{
					this->visualizacaosiglas=true;
					this->tbs_salvar.set_sensitive (false);
					this->tbs_excluir.set_sensitive (true);
					this->tbs_alterar.set_sensitive (true);
					this->tbs_novo.set_sensitive (true);
					this->tbs_cancelar.set_sensitive (false);

					SNavega.set_sensitive(true);
					SNavega.set_sensitive(true);
					SNavega.set_sensitive(true);
					SNavega.set_sensitive(true);
					SNavega.set_sensitive(true);

					entSiglas.set_sensitive (false);
					entSiglasPreencher.set_sensitive (false);
					SQL.clear();
					SQL = "insert into cadastro.siglas (sigla, cod_cid) values ('";
					SQL += ParaMaiusculos(this->entSiglas.get_text());
					SQL += "',";
//**********************************************************************
					var_aux.clear();
					cidade.clear();
					cidade=entSiglasPreencher.get_text();
					var_aux="select cod_cid from cadastro.municipio where estado='MS' and nome='"+cidade+"'";
					sqlaux = new char[var_aux.length()+1];
					strcpy(sqlaux,var_aux.c_str());
					this->conexao->executar(sqlaux);
					delete sqlaux;
					int totalcidade = this->conexao->registros;
					if( totalcidade==0)
						{
						Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
						Confirma.set_secondary_text("A cidade digitada não foi encontrada!!");
						Confirma.set_position(Gtk::WIN_POS_CENTER);
						Confirma.run();
						carregar_primeiro();
						}
					else
						{
						this->conexao->resultado();
						linha = this->conexao->resultados.at(0);
						var_aux.clear();
						var_aux=linha.at(0);
						//itoa(this->cod_reg,aux,10);
						//delete sqlaux;
						cidade.clear();
						cidade = "select cod_cid from cadastro.siglas where cod_cid=" +var_aux;
						sqlaux = new char[cidade.length()+1];
						strcpy(sqlaux,cidade.c_str());
						this->conexao->executar(sqlaux);
						delete sqlaux;
						int contador;
						if(this->conexao->registros > 0)
							{
							Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
							Confirma.set_secondary_text("Cidade já cadastrada!!");
							Confirma.set_position(Gtk::WIN_POS_CENTER);
							Confirma.run();
							carregar_primeiro();
							}
						else
							{
							SQL += var_aux;
	//**********************************************************************
							SQL += ")";
							sql = new char[SQL.length()+1];
							strcpy(sql,SQL.c_str());
							this->conexao->executar(sql);
							this->total=this->total+1;
							this->posicao=0;
							this->carregar_primeiro();
							}
						}
					break;
					}
				case 6:
					{
					arq_log.open("log.txt");
					log.clear();
					this->visualizacaocolmeias=true;
					
					var_aux.clear();
					var_aux2.clear();
					var_aux = this->entardatanas.get_text();
					var_aux2 = this->ent_ARloca.get_text();
					if(var_aux.length()<10 || var_aux2.length()==0)
						{
						Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
						Confirma.set_secondary_text("Entre com a Data de nascimento e Local de Nascimento correto!");
						Confirma.set_position(Gtk::WIN_POS_CENTER);
						Confirma.run();
						this->acao_abelha=1;
						novo();
						}
					else
						{
						this->tbar_salvar.set_sensitive (false);
						this->tbar_excluir.set_sensitive (true);
						this->tbar_alterar.set_sensitive (true);
						this->tbar_novo.set_sensitive (true);
						this->tbar_cancelar.set_sensitive (false);

						entarrg.set_sensitive (false);
						entarcodatual.set_sensitive (false);
						entarcodnovo.set_sensitive (false);
						entardatanas.set_sensitive (false);
						entardatafec.set_sensitive (false);
						entardatarev.set_sensitive (false);
						entargera.set_sensitive (false);
						entarrgmae.set_sensitive (false);
						CBRainha.set_sensitive (false);
						CBRcolmeia.set_sensitive(false);
						ScrollarObs.set_sensitive (false);
						entarconsultar.set_sensitive (true);
						ent_ARloca.set_sensitive(false);
						ARNavega.set_sensitive(true);
						ARNavega.set_sensitive(true);
						ARNavega.set_sensitive(true);
						ARNavega.set_sensitive(true);
						ARNavega.set_sensitive(true);

						SQL.clear();
						SQL = "begin;";
						sql = new char[SQL.length()+1];
						strcpy(sql,SQL.c_str());
						conexao->executar(sql);
						delete sql;

						SQL.clear();
						SQL = "insert into cadastro.abelha_rainha (cod_atual, data_nascimento, data_fecundacao,geracao,rg_mae,obs,id_col,data_form,apiario) values (";
						SQL += this->entarcodatual.get_text();
						SQL += ",";
						var_aux.clear();
						var_aux = this->entardatanas.get_text();
						if(var_aux.length()>=10)
							{
							SQL += "'"+var_aux+"',";
							}
						else
							{
							SQL += "null,";
							}
						var_aux.clear();
						var_aux = this->entardatafec.get_text();
						if(var_aux.length()>=10)
							{
							SQL += "'"+var_aux+"','";
							}
						else
							{
							SQL += "null,'";
							}
						SQL += this->entargera.get_text();
						SQL += "',";
						contador = this->CBRainha.get_active();
						if(contador)
							{
							registro=*contador;
							if(registro)
								{
								this->cod_rgmae=registro[arvore_reg.reg];
								}
							}
						aux = new char[32];
						if(this->cod_rgmae==0)
							{
							strcpy(aux,"null");
							}
						else
							{
							sprintf(aux,"%d",this->cod_rgmae);
							}
						SQL.append(aux);
						delete aux;
						SQL += ",'";
						this->PObs3 = Gtk::TextBuffer::create ();
						this->PObs3 = RainhaObs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
						SQL += this->PObs3->get_text();
						SQL += "',";
						this->id_colmeia.clear();
						this->id_colmeia=CBRcolmeia.get_text();
						if(this->id_colmeia.length()==0)
							{
							SQL += "null,null,";
							}
						else
							{
							string colmeia;
							colmeia.clear();
							int contaux;
							contaux= this->id_colmeia.find(" ");
							if (contaux!= string::npos)
								{
								SQL += id_colmeia.substr(0,contaux);
								}
							SQL += ",'";
							this->data_form.clear();
							this->data_form = this->id_colmeia.substr(contaux+2,this->id_colmeia.length());

							char *Data_formatada;
							Data_formatada = new char[this->data_form.length()+1];	
							strcpy(Data_formatada,this->data_form.c_str());
							SQL += data_formatada(Data_formatada, 1);
							delete Data_formatada;
		 					SQL += "',";
							}
						if(this->ent_ARloca.get_text_length() > 0)
							{
							string auxiliaridapi;
							int i,j, cont;
							auxiliaridapi.clear();
							auxiliaridapi = ent_ARloca.get_text();
							i = auxiliaridapi.find('<');
							if (i != string::npos)
								{
								j = auxiliaridapi.find('>');
								}
							SQL += auxiliaridapi.substr(i+1,j-i-1);
							}
						else
							{
							SQL += "null ";
							}	

						SQL += ") RETURNING rg;";
						sql = new char[SQL.length()+1];
						strcpy(sql,SQL.c_str());
						this->conexao->executar(sql);
						arq_log << SQL << endl;;
						delete sql;
						if (this->conexao->registros > 0)
							{
							this->conexao->resultado();
							linha = this->conexao->resultados.at(0);
							log += this->conexao->mensagem;
							var_aux.clear();
							var_aux = this->entardatanas.get_text();
							var_aux2.clear();
							var_aux2 = this->codigo_rainha (result, var_aux.substr(3,2),var_aux.substr(6,4));
							SQL.clear();
							SQL = "update cadastro.abelha_rainha set cod_novo='"+var_aux2+"' where rg="+linha.at(0)+";";
							sql = new char[SQL.length()+1];
							strcpy(sql,SQL.c_str());
							arq_log << SQL << endl;
							this->conexao->executar(sql);
							delete sql;
							SQL.clear();
							SQL = "commit;";
							sql = new char[SQL.length()+1];
							strcpy(sql,SQL.c_str());
							conexao->executar(sql);
							delete sql;
							this->total++;
							this->posicao=0;
							}
						else
							{
							SQL.clear();
							SQL = "rollback;";
							sql = new char[SQL.length()+1];
							strcpy(sql,SQL.c_str());
							conexao->executar(sql);
							delete sql;
							}
						this->carregar_primeiro();
						arq_log << log << endl;
						arq_log.close();
						}
					break;
					}
				case 7:
					{
					if(ent_Florada.get_text_length() > 0)
						{
						strcpy(sql,"insert into cadastro.florada descricao values ('");
						var_aux.clear();
						var_aux =ParaMaiusculos(this->ent_Florada.get_text());	
						}
					else
						{
						cout<<"Teste de florada"<<endl; //**********************************************Parei aqui para testar
						}
					break;
					}
				}
			break;
			}
		case 2:
			{
			switch (this->janela)
				{
				case 1:
					{
					this->tba_salvar.set_sensitive (false);
					this->tba_excluir.set_sensitive (true);
					this->tba_alterar.set_sensitive (true);
					this->tba_novo.set_sensitive (true);
					this->tba_cancelar.set_sensitive (false);

					entNum.set_sensitive (false);
					entNome.set_sensitive (false);
					entSubreg.set_sensitive (false);
					entLoca.set_sensitive (false);
					entData.set_sensitive (false);
					ScrollObs.set_sensitive (false);
					entCons.set_sensitive (false);
					CFlorada.set_sensitive (false);
					entRegiao.set_sensitive(false);

					ANavega.set_sensitive(true);
					ANavega.set_sensitive(true);
					ANavega.set_sensitive(true);
					ANavega.set_sensitive(true);
					ANavega.set_sensitive(true);

					SQL.clear();
					SQL = "update cadastro.apiarios set nome='";
					SQL += this->entNome.get_text();
					SQL += "',cod_cid=";

					string cidade;
					cidade.clear();
					cidade=entRegiao.get_text();
					var_aux.clear();
					var_aux="select cod_cid from cadastro.municipio where estado='MS' and nome='"+cidade+"'";
					sqlaux = new char [var_aux.length()+1];
					strcpy(sqlaux,var_aux.c_str());
					this->conexao->executar(sqlaux);
					delete sqlaux;
					this->conexao->resultado();
					linha = this->conexao->resultados.at(0);
					var_aux.clear();
					var_aux=linha.at(0);
					SQL += var_aux;
					SQL += ",sub_regiao='";
					SQL += this->entSubreg.get_text();
					SQL += "',local='";
					SQL += this->entLoca.get_text();
					SQL += "',data=";

					if(this->entData.get_text_length() > 0)
						{
						SQL += "'";
						SQL += this->entData.get_text();
						SQL += "',id_flor=";
						}
					else
						{
						SQL += "null,id_flor=";
						}

					contador = this->CFlorada.get_active();
					if(contador)
						{
						registro=*contador;
						if(registro)
							{
							this->cod_florada=registro[arvore_reg.reg];
							}
						}
					aux = new char[32];
					sprintf(aux,"%d",this->cod_florada);
					SQL.append(aux);
					delete aux;
					SQL += ",obs='";
					this->PObs1 = Gtk::TextBuffer::create ();
					this->PObs1 = TObs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
					SQL += this->PObs1->get_text();
					SQL += "' where id_api=";
					SQL += this->id_selecionado;
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					this->posicao=0;
					//this->carregar_primeiro();
					break;
					}
				case 2:
					{
					this->tbc_salvar.set_sensitive (false);
					this->tbc_novo.set_sensitive (true);
					this->tbc_alterar.set_sensitive (true);
					this->tbc_cancelar.set_sensitive (false);

					entCcolmeia.set_sensitive (false);
					entCdatafor.set_sensitive (false);
					CTipo.set_sensitive (false);
					CAtividade.set_sensitive (false);
					ColObs.set_editable (false);
					CNavega.set_sensitive(true);
					CNavega.set_sensitive(true);
					CNavega.set_sensitive(true);
					CNavega.set_sensitive(true);
					CNavega.set_sensitive(true);
					
					SQL.clear();
					SQL = "update cadastro.colmeias set tipo=";
					contador = this->CTipo.get_active();
					if(contador)
						{
						registro=*contador;
						if(registro)
							{
							this->cod_tp=registro[arvore_reg.reg];
							}
						}
					aux = new char[32];
					sprintf(aux,"%d",this->cod_tp);
					SQL.append (aux);
					delete aux;
					SQL += ",status=";
					contador = this->CAtividade.get_active();
					if(contador)
						{
						registro=*contador;
						if(registro)
							{
							this->cod_st=registro[arvore_reg.reg];
							}
						}
					aux = new char[32];
					sprintf(aux,"%d",this->cod_st);
					SQL.append (aux);
					delete aux;
					SQL += ",obs ='";
					PObs4 = Gtk::TextBuffer::create ();
					PObs4 = ColObs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
					var_aux.clear();
					var_aux= PObs4->get_text();
					SQL += var_aux;
						
					SQL += "',flag=1 where id_col=";
					SQL += this->entCcolmeia.get_text();
					SQL += " and data_form='";
					SQL += this->entCdatafor.get_text();
					SQL += "'";
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					arq_log.open("log.txt");
					arq_log << sql << endl;
					this->conexao->executar(sql);
					delete sql;
					if (this->conexao->query_result == 3)
						{
						arq_log << this->conexao->mensagem << endl;
						}
					//cout<<this->mensagem;
					//this->posicao=0;
					this->carregar_primeiro();
					break;
					}
				case 3:
					{
					this->tbp_salvar.set_sensitive (false);
					this->tbp_excluir.set_sensitive (true);
					this->tbp_alterar.set_sensitive (true);
					this->tbp_novo.set_sensitive (true);
					this->tbp_cancelar.set_sensitive (false);

					entPnum.set_sensitive (false);
					entPdata.set_sensitive (false);
					entPhrini.set_sensitive (false);
					entPhrfim.set_sensitive (false);
					CBPTipo.set_sensitive (false);
					entPApiario.set_sensitive (false);
					ScrollPlanObs.set_sensitive (false);
					entPplannum.set_sensitive (true);
					PNavega.set_sensitive(true);
					PNavega.set_sensitive(true);
					PNavega.set_sensitive(true);
					PNavega.set_sensitive(true);
					PNavega.set_sensitive(true);
					SQL.clear();
					SQL = "update cadastro.planilhas set data=";
					if(this->entPdata.get_text_length() > 0)
						{
						SQL += "'";
						SQL += this->entPdata.get_text();
						SQL += "',";
						}
					else
						{
						SQL += "null,";
						}
					SQL += "horai=";
					if(this->entPhrini.get_text_length() == 5)
						{
						SQL += "'";
						SQL += this->entPhrini.get_text();
						SQL += "',";
						}
					else
						{
						SQL += "null,";
						}

					SQL += "horaf=";
					if(this->entPhrfim.get_text_length() == 5)
						{
						SQL += "'";
						SQL += this->entPhrfim.get_text();
						SQL += "',";
						}
					else
						{
						SQL += "null,";
						}
					SQL += "tipo=";
					contador = this->CBPTipo.get_active();
					if(contador)
						{
						registro=*contador;
						if(registro)
							{
							this->tipo_planilha=registro[arvore_reg.reg];
							}
						}
					aux = new char [32];
					sprintf(aux,"%d",this->tipo_planilha);
					SQL.append (aux);
					SQL += ",apiario=";
	//***************************************************
					SQL.append(cod_apiario);
	//***************************************************
					SQL += ",obs='";
					this->PObs2 = Gtk::TextBuffer::create ();
					this->PObs2 = PlanObs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
					SQL += this->PObs2->get_text();
					SQL += "' where nump=";
					SQL += this->id_selecionado;
					sql = new char [SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					//this->posicao=0;
				
					break;
					}
				case 5:
					{
					this->tbs_salvar.set_sensitive (false);
					this->tbs_excluir.set_sensitive (true);
					this->tbs_alterar.set_sensitive (true);
					this->tbs_novo.set_sensitive (true);
					this->tbs_cancelar.set_sensitive (false);

					entSiglas.set_sensitive (false);
					SNavega.set_sensitive(true);
					SNavega.set_sensitive(true);
					SNavega.set_sensitive(true);
					SNavega.set_sensitive(true);
					SNavega.set_sensitive(true);
					CSiglas.set_sensitive (false);

					SQL.clear();
					SQL = "update cadastro.siglas set sigla='";
					var_aux =ParaMaiusculos(this->entSiglas.get_text());
					SQL += var_aux;
					SQL += "',cod_cid=";
					contador = this->CSiglas.get_active();
					if(contador)
						{
						registro=*contador;
						if(registro)
							{
							this->cod_reg=registro[arvore_reg.reg];
							}
						}
					aux = new char[32];
					sprintf(aux,"%d",this->cod_reg);
					SQL.append (aux);
					SQL += " where cod_cid=";
					SQL.append (aux);
					delete aux;
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					delete sql;
					this->posicao=0;
					this->carregar_primeiro();
					break;
					}
				case 6:
					{
					var_aux.clear();
					var_aux = this->entardatanas.get_text();
					if(var_aux.length()<10)
						{
						Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
						Confirma.set_secondary_text("Entre com a Data de nascimento correta!");
						Confirma.set_position(Gtk::WIN_POS_CENTER);
						Confirma.run();
						this->acao_abelha=1;
						editar_registro();
						}
					else
						{
						this->tbar_salvar.set_sensitive (false);
						this->tbar_excluir.set_sensitive (true);
						this->tbar_alterar.set_sensitive (true);
						this->tbar_novo.set_sensitive (true);
						this->tbar_cancelar.set_sensitive (false);

				//		entarrg.set_sensitive (false);
						entarcodatual.set_sensitive (false);
						entarcodnovo.set_sensitive (false);
						entardatanas.set_sensitive (false);
						entardatafec.set_sensitive (false);
						entargera.set_sensitive (false);
						entarrgmae.set_sensitive (false);
						CBRainha.set_sensitive (false);
						CBRcolmeia.set_sensitive (false);
						ScrollarObs.set_sensitive (false);
						entarconsultar.set_sensitive (true);

						ARNavega.set_sensitive(true);
						ARNavega.set_sensitive(true);
						ARNavega.set_sensitive(true);
						ARNavega.set_sensitive(true);
						ARNavega.set_sensitive(true);

						SQL.clear();
						SQL = "update cadastro.abelha_rainha set cod_atual=";
						SQL += this->entarcodatual.get_text();
						SQL += ",data_nascimento='";
						SQL += this->entardatanas.get_text();
						SQL += "',data_fecundacao=";
						if(this->entardatafec.get_text_length() > 0)
							{
							SQL += "'";
							SQL += this->entardatafec.get_text();
							SQL += "',";
							}
						else
							{
							SQL += "null,";
							}
						SQL += "apiario=";
						char *cod_apiariolocal;
						cod_apiariolocal = new char[20];
						sprintf(cod_apiariolocal,"%d",this->cod_apiarioar);
						SQL.append (cod_apiariolocal);
						delete cod_apiariolocal;
						SQL += ",geracao='";
						SQL += this->entargera.get_text();
						SQL += "',obs='";
						this->PObs3 = Gtk::TextBuffer::create ();
						this->PObs3 = RainhaObs.get_buffer();  //ponteiro pega o buffer e para pegar o texto que tem no buffer usa se o ponteiro com get_text
						SQL += this->PObs3->get_text();
						SQL += "',id_col=";
						cout << __LINE__ << ": " << id_col <<endl;
						this->id_colmeia.clear();
						this->id_colmeia=CBRcolmeia.get_text();
						if(this->id_colmeia.length()==0)
							{
							SQL += "null,data_form=null";
							}
						else
							{
							string colmeia;
							colmeia.clear();
							int contaux;
							contaux= this->id_colmeia.find(" ");
							if (contaux!= string::npos)
								{
								SQL += id_colmeia.substr(0,contaux);
								}
							SQL += ",data_form='";
							this->data_form.clear();
							this->data_form = this->id_colmeia.substr(contaux+2,this->id_colmeia.length());
							char *Data_formatada;
							Data_formatada = new char[this->data_form.length()+1];	
							strcpy(Data_formatada,this->data_form.c_str());
							SQL += data_formatada(Data_formatada, 2);
							delete Data_formatada;
							SQL +="'";
							}
						SQL += " where rg=";
						SQL += this->entarrg.get_text();
						sql = new char[SQL.length()+1];
						strcpy(sql,SQL.c_str());
						cout << sql << endl;
						this->conexao->executar(sql);
						delete sql;
						if (conexao->query_result == 3)
							{
							cout << conexao->mensagem << endl;
							}
						}
					break;
					}
				}
			break;
			}
		case 3:
			{
			string conversao; //variavel para salvar o valor dentro das entrys 
			switch (this->janela)
				{
				case 1:
					{
					if(this->total>=0)
						{
						SQL.clear();
						SQL = "delete from cadastro.apiarios where id_api=";
						SQL += id_selecionado;
						sql = new char[SQL.length()+1];
						strcpy(sql,SQL.c_str());
						cout<<sql<<endl;
						this->conexao->executar(sql);
						delete sql;
						cout<<this->conexao->mensagem<<endl;
						this->total--;
						this->posicao=0;
						this->carregar_primeiro();
						}
					else
						{
						Gtk::MessageDialog Aviso_Busca(Glib::ustring("Atenção"), false);
						Aviso_Busca.set_secondary_text(Glib::ustring("Não existe mais Registro para ser apagado!"));
						Aviso_Busca.set_position(Gtk::WIN_POS_CENTER);
						Aviso_Busca.run();
						}
					break;
					}
				case 3:
					{
					if(this->total>=0)
						{
						SQL.clear();
						SQL = "delete from cadastro.planilhas where nump=";
						SQL += this->id_selecionado;
						sql = new char[SQL.length()+1];
						strcpy(sql,SQL.c_str());
						this->conexao->executar(sql);
						this->total=this->total-1;
						this->posicao=0;
						this->carregar_primeiro();
						}
					else
						{
						Gtk::MessageDialog Aviso_Busca(Glib::ustring("Atenção"), false);
						Aviso_Busca.set_secondary_text(Glib::ustring("Não existe mais Registro para ser apagado!"));
						Aviso_Busca.set_position(Gtk::WIN_POS_CENTER);
						Aviso_Busca.run();
						}
					break;
					}
				case 5:
					{
					if(this->total>0)
						{
						SQL.clear();
						SQL = "delete from cadastro.siglas where cod_cid=";
						aux = new char[32];
						sprintf(aux,"%d",this->cod_reg);//converter para caracter
						SQL.append (aux); 
						delete aux;
						sql = new char[SQL.length()+1];
						strcpy(sql,SQL.c_str());
						this->conexao->executar(sql);
						delete sql;
						this->total=this->total-1;
						this->posicao=0;
						this->carregar_primeiro();
						}
					else
						{						
						Gtk::MessageDialog Aviso_Busca(Glib::ustring("Atenção"), false);
						Aviso_Busca.set_secondary_text(Glib::ustring("Não existe mais Registro para ser apagado!"));
						Aviso_Busca.set_position(Gtk::WIN_POS_CENTER);
						Aviso_Busca.run();
						}
						
					break;
					}
				case 6:
					{
					if(this->total>0)
						{
						SQL.clear();
						SQL = "delete from cadastro.abelha_rainha where rg=";
						SQL += this->entarrg.get_text();
						sql = new char[SQL.length()+1];
		 				strcpy(sql, SQL.c_str());
						cout<<sql<<endl;
						this->conexao->executar(sql);
						delete sql;
						this->total--;
						this->posicao=0;
						this->carregar_primeiro();
						}
					else
						{
						Gtk::MessageDialog Aviso_Busca(Glib::ustring("Atenção"), false);
						Aviso_Busca.set_secondary_text(Glib::ustring("Não existe mais Registro para ser apagado!"));
						Aviso_Busca.set_position(Gtk::WIN_POS_CENTER);
						Aviso_Busca.run();
						}
					break;
					}
				}
			break;
			}
		}
	}

/**
 * Confirmação de Exclusão de Registro
 */
void CADASTRO :: excluir()
	{
	bool decisao;
	Gtk::MessageDialog Confirma(Glib::ustring("Confirmação de exclusão"), false);
	Confirma.set_secondary_text("Deseja excluir o registro?");
	Confirma.set_position(Gtk::WIN_POS_CENTER);
	//Confirma.add_button(Gtk::Stock::YES,true);
	Confirma.add_button(Gtk::Stock::NO, false);
	decisao = Confirma.run();
	if(decisao)
		{
		this->acao=3;
		this->armazenar_registro();
		}
	}

/**
 * Preparando box de clientes
 */
void CADASTRO::prepara_box_cliente()
	{
	char *sql, i,j, *aux;
	int total_reg, total_col, nota;
	string SQL, AUX, aux_a, contador_colmeia;
	vector<vector<string> >::iterator ir;
	vector<string> linha;
		
	switch (this->janela)
		{
		case 1:
			{
			contador_colmeia.clear();
			SQL.clear();
			SQL = "select count(*) from historico.producaotemp where id_apiario=";
			SQL += this->id_selecionado;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout<<"teste de sql do apiario  "<<sql<<endl;
			//strcat(sql, " group by colmeias.id_col, colmeias.tipo, api_col.data_intr");
			this->conexao->executar(sql);
			delete sql;
			this->conexao->resultado();
			linha = this->conexao->resultados.at(0);
			this->total_geral = atoi(linha.at(0).c_str());
			this->paginas = (int) ceil(this->total_geral/this->limite);
			this->offset = this->pagina_apicol * this->limite;
			this->total_apicol= this->paginas;
			this->pos_atual=this->pagina_apicol;
			this->pos_atual=pos_atual+1;
			AUX.clear();
			AUX = "Registro nº: ";
			aux = new char[64];
			sprintf(aux,"%d / %d", pos_atual, this->total_apicol+1);
			AUX.append (aux);
			delete aux;
			this->navegacaoapiario.set_text (Glib::ustring(AUX));
			contador_colmeia ="<span font='12'><i><b>Total de Colmeias: ";
			contador_colmeia+=linha.at(0);
			contador_colmeia+="</b></i></span> ";
			enttotalcolmeias.set_markup(contador_colmeia);
			SQL.clear();
			SQL = "select id_colmeia, data_formacao, rainha, nota from historico.producaotemp where id_apiario=";
			SQL += this->id_selecionado;
			//strcpy(sql,"select colmeias.id_col, colmeias.tipo, api_col.data_intr from cadastro.colmeias, cadastro.api_col where  colmeias.id_col = api_col.id_col and colmeias.data_form = api_col.data_form and api_col.id_api= ");
			//strcat(sql,this->id_selecionado.c_str());
			//strcat(sql, " group by colmeias.id_col, colmeias.tipo, api_col.data_intr order by id_col  limit 10 offset ");
			SQL += "order by id_colmeia limit 10 offset ";
			aux = new char [32];
			sprintf(aux,"%d",offset);
			SQL.append (aux);
			delete aux;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			cout<<sql<<endl;
			//cout<<"teste offset e sql	 "<<offset<<endl<<sql<<endl;
			this->conexao->executar(sql);
			delete sql;
			this->total_registros=this->conexao->registros;
			this->total_colunas=this->conexao->colunas;
			//cout<<"Total coluna "<<this->total_colunas<<" "<<this->total_registros<<endl;

			ponteiro_lista = Gtk::ListStore::create(Colunas_Cliente);
			listaCliente.set_model(ponteiro_lista);
			Gtk::TreeModel::Row coluna;
			this->conexao->resultado();
			for (ir=this->conexao->resultados.begin(); ir < this->conexao->resultados.end(); ir++)
				{
				linha = *ir;
				coluna = *(ponteiro_lista->append());
				for(j=0;j<this->total_colunas;j++)
					{
					switch(j)
						{
						case 1:
							{
							aux = new char[32];
							strcpy(aux,linha.at(j).c_str());
							coluna[Colunas_Cliente.campo[j]]= data_formatada(aux, 2);
							delete aux;
							break;
							}
						case 3:
							{
							nota = atoi(linha.at(j).c_str());
							switch (nota)
								{
								
								case 1:
									{
									coluna[Colunas_Cliente.campo[j]]="Ótima";
									break;
									}
								case 2:
									{
									coluna[Colunas_Cliente.campo[j]]="Boa";
									break;
									}
								case 3:
									{
									coluna[Colunas_Cliente.campo[j]]="Ruim";
									break;
									}
								case 4:
									{
									coluna[Colunas_Cliente.campo[j]]="Avaliar";
									break;
									}
								}
							break;
							}
						default:
							{
							coluna[Colunas_Cliente.campo[j]]= linha.at(j);
							break;
							}
						}
					}
				}
			listaCliente.remove_all_columns();
			listaCliente.append_column(Glib::ustring("Código Colmeia"), Colunas_Cliente.campo[0]);
			listaCliente.append_column(Glib::ustring("Data de Introdução"), Colunas_Cliente.campo[1]);
			listaCliente.append_column(Glib::ustring("Rainha"), Colunas_Cliente.campo[2]);
			listaCliente.append_column(Glib::ustring("Situação"), Colunas_Cliente.campo[3]);
			//listaCliente.append_column("CIDADE / ESTADO", Colunas_Cliente.campo[2]);

			//FAZ COM QUE TODAS AS COLUNAS FIQUEM REORDENÁVEIS
			for(i=0; i < 3; i++)
				{
				Gtk::TreeView::Column* coluna_temp = listaCliente.get_column(i);
				coluna_temp->set_reorderable();
				}
			
			break;
			}
		case 4:
			{
			aux_a.clear();
			if(entRLocalizar.get_text_length() !=0)
				{
				aux_a = entRLocalizar.get_text();
				aux_a = " and nome like '"+aux_a+"%%'";
				}
			SQL.clear();
			SQL = "select cod_cid,nome from cadastro.municipio where estado='MS'" + aux_a;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			this->total_registros=this->conexao->registros;
			this->total_colunas=this->conexao->colunas;

			ponteiro_lista = Gtk::ListStore::create(Colunas_Cliente);
			listaCliente.set_model(ponteiro_lista);
			Gtk::TreeModel::Row coluna;
			this->conexao->resultado();
			for (ir=this->conexao->resultados.begin(); ir < this->conexao->resultados.end(); ir++)
				{
				linha = *ir;
				coluna = *(ponteiro_lista->append());
				for(j=0;j<this->total_colunas;j++)
					{
					coluna[Colunas_Cliente.campo[j]]= linha.at(j);
					}
				}
			listaCliente.remove_all_columns();
			listaCliente.append_column(Glib::ustring("Código"), Colunas_Cliente.campo[0]);
			listaCliente.append_column(Glib::ustring("Região"), Colunas_Cliente.campo[1]);
			//listaCliente.append_column("CIDADE / ESTADO", Colunas_Cliente.campo[2]);

			//FAZ COM QUE TODAS AS COLUNAS FIQUEM REORDENÁVEIS
			for(i=0; i < 2; i++)
				{
				Gtk::TreeView::Column* coluna_temp = listaCliente.get_column(i);
				coluna_temp->set_reorderable();
				}
			break;
			}
		}
	}

/**
 * 
 */
void CADASTRO :: gerar_codigo()
	{
	char *sql, *aux;
	string SQL, AUX, codigo, cidade_temp, sigla, dados;
	vector<string> linha;
	
	cidade_temp.clear();
	
	if(this->acao==1)
		{
		cidade_temp = this->entRegiao.get_text();
		}
	SQL.clear();
	SQL = "select siglas.* from cadastro.municipio natural join cadastro.siglas where municipio.nome='" + cidade_temp + "'";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->registros > 0)
		{
		this->conexao->resultado();
		linha = this->conexao->resultados.at(0);
		codigo.clear();
		sigla.clear();
		codigo=linha.at(1);
		sigla=linha.at(0);
	
		dados.clear();
		dados="select count(*) from cadastro.apiarios where cod_cid="+codigo;
		//cout<<dados<<endl;
		sql = new char[dados.length()+1];
		strcpy(sql,dados.c_str());
		this->conexao->executar(sql);
		delete sql;
		this->conexao->resultado();
		linha = this->conexao->resultados.at(0);
		this->flag=atoi(linha.at(0).c_str());
		this->flag++;
		cout<<"teste"<<sigla<<"teste"<<flag<<"teste"<<endl;
		aux = new char[32];
		sprintf(aux,"%s%03d\0",sigla.c_str(),this->flag);
		codigo.clear();
		codigo=aux;
		cout<<"teste"<<codigo<<"teste"<<endl;
		this->entNum.set_text(Glib::ustring (codigo));
		entRegiao.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Apiarios,&this->entSubreg));
		delete aux;
		}
	else
		{
		Gtk::MessageDialog Confirma(Glib::ustring("Atenção"), false);
		Confirma.set_secondary_text("Região não cadastrada! Vá para o menu cadastro, submenu siglas e cadastre a região desejada!");
		Confirma.set_position(Gtk::WIN_POS_CENTER);
		Confirma.run();
		Confirma.hide();
		entRegiao.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&CADASTRO::setar_focus),&this->Apiarios,&this->entRegiao));
		entRegiao.set_text("");
		this->acao=1;
		
		//Siglas.show_all();
		this->janela=5;
		janelas();
		Gtk::Main::run(Siglas);
		this->janela=1;
		//this->carregar_primeiro();
		}
	}

/**
 *
 */
void CADASTRO :: buscar_registro ()
	{	
	this->botao_consultar=true;
	cout<<"teste dentro do buscar registro"<<endl;
	carregar_primeiro();
	}

/**
 *
 */
void CADASTRO :: cancelar ()
	{
	bool decisao;
	Gtk::MessageDialog Confirma(Glib::ustring("Confirmação de cancelamento"), false);
	Confirma.set_secondary_text("Deseja cancelar o registro?");
	Confirma.set_position(Gtk::WIN_POS_CENTER);
	//Confirma.add_button(Gtk::Stock::YES,true);
	Confirma.add_button(Gtk::Stock::NO, false);
	decisao = Confirma.run();
	if(decisao)
		{
		this->botao_consultar==false;
		this->posicao=1;
		carregar_primeiro();
		}
	}

/**
 * \param tela
 */
void CADASTRO::checar_nome(int tela)
	{
	string digitado;

  	digitado.clear();

	switch(tela)
		{
		case 4:
			{
			digitado =entRLocalizar.get_text();
			if(digitado.length() == 1)
				{
				digitado = ParaMaiusculos(digitado);
				}	
			entRLocalizar.set_text(digitado);
			this->prepara_box_cliente();
			
			break;
			}
		case 5:
			{
			digitado =entSiglas.get_text();
			digitado = ParaMaiusculos(digitado);
			entSiglas.set_text(digitado);				
			break;
			}
		case 6:
			{
			digitado =enttab_apiario.get_text();
			if(digitado.length() == 1)
				{
				digitado = ParaMaiusculos(digitado);
				}	
			enttab_apiario.set_text(digitado);
			this->prepara_box_tabela();
			
			}
		}
	}

/**
 * \param opc
 */
void CADASTRO :: navega_apicol(int opc)
	{
	switch(opc)
		{
		case 1:
			{
			if (this->pagina_apicol == 0)
				{
				Gtk::MessageDialog Aviso_Pagina(Glib::ustring("Atenção"), false);
				Aviso_Pagina.set_secondary_text(Glib::ustring("Você já está na primeira pagina!"));
				Aviso_Pagina.set_position(Gtk::WIN_POS_CENTER);
				Aviso_Pagina.run();
				}
			else 
				if (this->pagina_apicol> 0)
				{
				this->pagina_apicol = 0;
				}
			break;
			}
		case 2:
			{
			if (this->pagina_apicol == 0 )
				{
				Gtk::MessageDialog Aviso_Pagina(Glib::ustring("Atenção"), false);
				Aviso_Pagina.set_secondary_text(Glib::ustring("Você já está na primeira pagina!"));
				Aviso_Pagina.set_position(Gtk::WIN_POS_CENTER);
				Aviso_Pagina.run();
				}
		  	else if(this->pagina_apicol > 0)
				{
				this->pagina_apicol--;;
				}
			break;
			}
		case 3:
			{
			cout<<"valor de pagina e paginas "<<this->pagina<<" "<<this->paginas<<endl;
			if (this->pagina_apicol == this->paginas)
				{
				Gtk::MessageDialog Aviso_Pagina(Glib::ustring("Atenção"), false);
				Aviso_Pagina.set_secondary_text(Glib::ustring("Você já está na ultima pagina!"));
				Aviso_Pagina.set_position(Gtk::WIN_POS_CENTER);
				Aviso_Pagina.run();
				}
	
			else if (this->pagina_apicol < this->paginas)
				{
				this->pagina_apicol++;
				}
			break;
			}
		case 4:
			{
			//cout<<"valor de pagina e paginas"<<this->pagina<<" "<<this->janelas<<endl;
			if (this->pagina_apicol == this->paginas)
				{
				Gtk::MessageDialog Aviso_Pagina(Glib::ustring("Atenção"), false);
				Aviso_Pagina.set_secondary_text(Glib::ustring("Você já está na ultima pagina!"));
				Aviso_Pagina.set_position(Gtk::WIN_POS_CENTER);
				Aviso_Pagina.run();
				}
				
			else if (this->pagina_apicol < this->paginas)
				{
				this->pagina_apicol= this->paginas;
				}
			break;
			}		
		}
	this->prepara_box_cliente();
	}

/**
 * 
 */
void CADASTRO :: relatorio_planilha ()
	{
	char *arquivo;
	PDFNEW *pdf_arquivo;

	arquivo = new char[100];
	
	strcpy(arquivo,"Relatorio");
	cout << __FILE__ << ": " << __LINE__ << " " << cod_api << " " << cod_apiario << endl;
	pdf_arquivo = new PDFNEW(arquivo, this->tipo_planilha, this->cod_apiario );
	pdf_arquivo->set_cabecalho();
	pdf_arquivo->set_texto();
	pdf_arquivo->set_rodape();
	delete pdf_arquivo;
	//strcat(arquivo,".pdf");

	/*#if  !defined(__WIN32__) && !defined(__WIN__)
	sprintf (comando,"/usr/bin/gnome-open %s",arquivo);
	system (comando);
	#else
	ShellExecute(0, "open", arquivo, NULL, NULL, SW_SHOWDEFAULT);
	#endif    */
	}

/**
 * \param opc
 */
void CADASTRO :: configuracao_data(int opc)  //seta as mascaras das datas e no case 7 deixa a entry rg da rainha aceitando somente numeros
	{
	string aux;
	int len;
	int teste; //variavel que pega a posicao do texto na entry
	string mascara, saida;
	int j;				
	mascara.clear();
	mascara = "##/##/####";
	switch(opc)
		{
		case 1:
			{
			aux = this->entData.get_text();
			len = aux.length();
			if(isdigit(aux[len-1]) || (aux[len-1] == '/'))  //para aceitar alem dos numeros o caracter virgula
				{
				if ((len_ant > 0) && (len_ant > len))
					{
					len_ant--;
					aux[len_ant]='\0';
					}
				else if (len < 10)
					{
					if(mascara[len] !='#')
						{
						aux += mascara [len];
						}
				if((aux[len-1] == '/')&&(aux[len-2] == '/'))
						{
						aux[len-1] = '\0';
						}
					this->entData.set_text(aux);
					set_posicao(&this->entData,len+1);
					}
				len_ant = len;
				}
			else
				{
				aux[len-1]='\0';
				this->entData.set_text(aux);
				}
			break;
			}
		case 2:
			{
			aux = this->entardatanas.get_text();
			len = aux.length();
			// entardatanas, entardatafec,entardatarev
			if(isdigit(aux[len-1]) || (aux[len-1] == '/'))  //para aceitar alem dos numeros o caracter barra
				{
				if ((len_ant > 0) && (len_ant > len))
					{
					len_ant--;
					aux[len_ant]='\0';
					}
				else if (len < 10)
					{
					if(mascara[len] !='#')
						{
						aux += mascara [len];
						}
					if((aux[len-1] == '/')&&(aux[len-2] == '/'))
						{
						aux[len-1] = '\0';
						}
					this->entardatanas.set_text(aux);
					set_posicao(&this->entardatanas,len+1);
					}
				len_ant = len;
				}
			else
				{
				aux[len-1]='\0';
				this->entardatanas.set_text(aux);
				}
			break;
			}
		case 3:
			{
			aux = this->entardatafec.get_text();
			len = aux.length();
			// entardatanas, entardatafec,entardatarev
			if(isdigit(aux[len-1]) || (aux[len-1] == '/'))  //para aceitar alem dos numeros o caracter barra
				{
				if ((len_ant > 0) && (len_ant > len))
					{
					len_ant--;
					aux[len_ant]='\0';
					}
				else if (len < 10)
					{
					if(mascara[len] !='#')
						{
						aux += mascara [len];
						}
					if((aux[len-1] == '/')&&(aux[len-2] == '/'))
						{
						aux[len-1] = '\0';
						}
					this->entardatafec.set_text(aux);
					set_posicao(&this->entardatafec,len+1);
					}
				len_ant = len;
				}
			else
				{
				aux[len-1]='\0';
				this->entardatafec.set_text(aux);
				}
			break;
			}
		case 4:
			{
			aux = this->entardatarev.get_text();
			len = aux.length();
			// entardatanas, entardatafec,entardatarev
			if(isdigit(aux[len-1]) || (aux[len-1] == '/'))  //para aceitar alem dos numeros o caracter barra
				{
				if ((len_ant > 0) && (len_ant > len))
					{
					len_ant--;
					aux[len_ant]='\0';
					}
				else if (len < 10)
					{
					if(mascara[len] !='#')
						{
						aux += mascara [len];
						}
					if((aux[len-1] == '/')&&(aux[len-2] == '/'))
						{
						aux[len-1] = '\0';
						}
					this->entardatarev.set_text(aux);
					set_posicao(&this->entardatarev,len+1);
					}
				len_ant = len;
				}
			else
				{
				aux[len-1]='\0';
				this->entardatarev.set_text(aux);
				}
			break;
			}
		case 5:
			{
			aux = this->entPdata.get_text();
			len = aux.length();
			// entardatanas, entardatafec,entardatarev
			if(isdigit(aux[len-1]) || (aux[len-1] == '/'))  //para aceitar alem dos numeros o caracter barra
				{
				if ((len_ant > 0) && (len_ant > len))
					{
					len_ant--;
					aux[len_ant]='\0';
					}
				else if (len < 10)
					{
					if(mascara[len] !='#')
						{
						aux += mascara [len];
						}
					if((aux[len-1] == '/')&&(aux[len-2] == '/'))
						{
						aux[len-1] = '\0';
						}
					this->entPdata.set_text(aux);
					set_posicao(&this->entPdata,len+1);
					}
				len_ant = len;
				}
			else
				{
				aux[len-1]='\0';
				this->entPdata.set_text(aux);
				}
			break;
			}	
		case 6:
			{
			aux = this->entCdatafor.get_text();
			len = aux.length();
			// entardatanas, entardatafec,entardatarev
			if(isdigit(aux[len-1])  || (aux[len-1] == '/'))  //para aceitar alem dos numeros o caracter barra
				{
				if ((len_ant > 0) && (len_ant > len))
					{
					len_ant--;
					aux[len_ant]='\0';
					}
				else if (len < 10)
					{
					if(mascara[len] !='#')
						{
						aux += mascara [len];
						}
					if((aux[len-1] == '/')&&(aux[len-2] == '/'))
						{
						aux[len-1] = '\0';
						}
					this->entCdatafor.set_text(aux);
					set_posicao(&this->entCdatafor,len+1);
					}
				len_ant = len;
				}
			else
				{
				aux[len-1]='\0';
				this->entCdatafor.set_text(aux);
				}
			break;
			}
		case 7:
			{
			aux = this->entarcodatual.get_text();
			len = aux.length();
			// entardatanas, entardatafec,entardatarev
			if(isdigit(aux[len-1]) )  //para aceitar apenas numeros
				{
				this->entarcodatual.set_text(aux);
				}
			else
				{
				aux[len-1]='\0';
				this->entarcodatual.set_text(aux);
				}
			break;
			}
		case 8:
			{
			aux = this->CBRcolmeia.get_text();
			len = aux.length();
			// entardatanas, entardatafec,entardatarev
			if(isdigit(aux[len-1]) )  //para aceitar apenas numeros
				{
				this->CBRcolmeia.set_text(aux);
				}
			else
				{
				aux[len-1]='\0';
				this->CBRcolmeia.set_text(aux);
				}
			break;
			}
		}
	}

/**
 * \param w
 * \param n
 */
void CADASTRO :: set_posicao (Gtk::Entry * w, int n)
	{
	Glib::signal_idle().connect
    	(sigc::bind_return
           (sigc::bind<int>
               (sigc::mem_fun (*w,&Gtk::Entry::set_position), n), false));
	}

/**
 * \param janela
 * \param destino
 */
void CADASTRO :: setar_focus (Gtk::Window *janela, Gtk::Widget *destino)
	{
	janela->set_focus(*destino);
	}

/**
 * \param opc
 */
void CADASTRO :: maiusculo(int opc)
	{
	string digitado_aux;
	digitado_aux.clear();	
	digitado_aux =entCons.get_text();
	digitado_aux = ParaMaiusculos(digitado_aux);
	entCons.set_text(digitado_aux);
	}

/**
 *
 */
void CADASTRO :: tabela_apiarios()
	{
	Tabela_Apiario.set_title(Glib::ustring("Tabela de Ápiarios"));
 	Tabela_Apiario.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
	Tabela_Apiario.set_position(Gtk::WIN_POS_CENTER);
 	Tabela_Apiario.set_default_size(400, 300);
	VB_tbap.set_homogeneous(false);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI
 	VB_tbap.set_spacing(0);

	HB_tbap.set_homogeneous(true);
 	HB_tbap.set_spacing(0);

	//coloca entry em uma HBOX na janela
	lab_tbapi.set_label("Entre com o nome do apiário: ");
	enttab_apiario.set_size_request(200,28);
	enttab_apiario.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::checar_nome),6));

	HB_tbap.pack_start(lab_tbapi, false, false,5);
	HB_tbap.pack_start(enttab_apiario, false, true,0);


	//Chamando a função para gerar as colunas
	scroll_tbap.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	scroll_tbap.add(lista_tbap);
	prepara_box_tabela();
	VB_tbap.pack_start(HB_tbap, false, true,5);
	VB_tbap.pack_start(scroll_tbap);

	enttab_apiario.signal_changed().connect(sigc::bind(sigc::mem_fun(*this, &CADASTRO::checar_nome),6));

	Tabela_Apiario.add(VB_tbap);
	VB_tbap.show_all();
	Gtk::Main::run(Tabela_Apiario);
	
	}

/**
 *
 */
void CADASTRO :: prepara_box_tabela()
	{
	int i, j;
	char *sql, *aux;
	string aux_a, SQL, AUX;
	vector<vector<string> >::iterator ir;
	vector<string> linha;
	
	aux_a.clear();
	if(enttab_apiario.get_text_length() !=0)
		{
		aux_a = enttab_apiario.get_text();
		aux_a = " where nome like '"+aux_a+"%%' order by codigo";
		}
	else
		{
		aux_a = "order by codigo";
		}
	SQL.clear();
	SQL = "select codigo, nome from cadastro.apiarios "+aux_a;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	this->total_registros=this->conexao->registros;
	this->total_colunas=this->conexao->colunas;

	ponteiro_tabela = Gtk::ListStore::create(Colunas_Cliente);
	lista_tbap.set_model(ponteiro_tabela);
	Gtk::TreeModel::Row coluna;
	this->conexao->resultado();
	for (ir=this->conexao->resultados.begin(); ir < this->conexao->resultados.end(); ir++)
		{
		linha = *ir;
		coluna = *(ponteiro_tabela->append());
		for(j=0;j<this->total_colunas;j++)
			{
			coluna[Colunas_Cliente.campo[j]]= linha.at(j);
			}
		}
	lista_tbap.remove_all_columns();
	lista_tbap.append_column(Glib::ustring("Código"), Colunas_Cliente.campo[0]);
	lista_tbap.append_column(Glib::ustring("Apiário"), Colunas_Cliente.campo[1]);
	//listaCliente.append_column("CIDADE / ESTADO", Colunas_Cliente.campo[2]);

	//FAZ COM QUE TODAS AS COLUNAS FIQUEM REORDENÁVEIS
	for(i=0; i < 2; i++)
		{
		Gtk::TreeView::Column* coluna_temp = lista_tbap.get_column(i);
		coluna_temp->set_reorderable();
		}
	lista_tbap.signal_row_activated().connect(sigc::mem_fun(*this,&CADASTRO::selecionado));
	}

/**
 * \param path
 * \param column
 */
void CADASTRO :: selecionado(const Gtk::TreeModel::Path& path,Gtk::TreeViewColumn* column)
	{
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	int i;
	Glib::ustring aux;
	char *aux2;
	//this->resposta=true;
	//this->controle=false;
	contador = ponteiro_tabela->get_iter(path);

	if(contador)
		{
		registro=*contador;
		if(registro)
			{
			cout<<"teste de seleção do codigo apiario"<<endl;
			aux.clear();
			
			aux=(registro[Colunas_Cliente.campo[0]]);
			cout<<aux<<endl;
			this->entCons.set_text(aux);
			Tabela_Apiario.hide();
			buscar_registro();
			
			}
		}
	}

/**
 /param rg registro da rainha
 /param mes mês de nascimento
 /param ano ano de nascimento
 */
string CADASTRO::codigo_rainha (int rg, string mes, string ano)
	{
	string AUX, SQL, novo_codigo;
	vector<string> linha;
	char *aux;
	int mes_i, ano_i, final, controle;
	BANCOPG *codrai;

	novo_codigo.clear();
	codrai = new BANCOPG(CONF_FILE);
	aux = new char[32];
	strcpy(aux,mes.c_str());
	mes_i = atoi(aux);
	delete aux;
	aux = new char[32];
	strcpy(aux,ano.c_str());
	ano_i = atoi(aux);
	delete aux;
	aux = new char[32];
	sprintf(aux, "-%02d%02d",mes_i,(ano_i%((ano_i/1000)*1000)));
	novo_codigo.append(aux);
	delete aux;
	switch(mes_i)
		{
		case 1:
		case 3:
		case 5:
		case 7:
		case 8:
		case 10:
		case 12:
			{
			final = 31;
			break;
			}
		case 2:
			{
			final = 28;
			if (!(ano_i % 4))
				{
				final = 29;
				}
			break;
			}
		case 4:
		case 6:
		case 9:
		case 11:
			{
			final = 30;
			break;
			}
		}
	SQL = "select count(rg) from cadastro.abelha_rainha where data_nascimento >='";
	aux = new char[32];
	sprintf(aux, "%04d-%02d-01",ano_i,mes_i);
	SQL.append(aux);
	delete aux;
	SQL += "' and data_nascimento <= '";
	aux = new char[32];
	sprintf(aux, "%04d-%02d-%02d",ano_i,mes_i,final);
	SQL.append(aux);
	delete aux;
	SQL += "'";
	aux = new char[SQL.length()+1];
	strcpy(aux,SQL.c_str());
	codrai->executar(aux);
	delete aux;
	if (codrai->query_result != 3)
		{
		codrai->resultado();
		linha.clear();
		linha = codrai->resultados.at(0);
		controle = atoi(linha.at(0).c_str());
		controle++;
		aux = new char[32];
		sprintf(aux,"%d",controle);
		SQL = "update cadastro.abelha_rainha set controle=";
		SQL.append (aux);
		delete aux;
		SQL += " where rg=";
		aux = new char[32];
		sprintf (aux,"%d",rg);
		SQL.append (aux);
		delete aux;
		aux = new char[SQL.length()+1];
		strcpy(aux,SQL.c_str());
		codrai->executar(aux);
		delete aux;
		if (codrai->query_result == 3)
			{
			cout << codrai->mensagem << endl;
			}
		aux = new char[32];
		sprintf(aux,"%04d",controle);
		AUX.clear();
		AUX.append (aux);
		delete aux;
		novo_codigo = AUX + novo_codigo;
		}
	delete codrai;
	return (novo_codigo);
	}

void CADASTRO::aplicar_mascara(string mascara, int onde, Gtk::Entry *e)
	{
	int tam;
	string data_dg;
	bool mudou;
	mudou = false;
	if (this->entry_ativa != onde)
		{
		this->entry_ativa = onde;
		mudou = true;
		}
	if (mudou)
		{
		this->pos_entry = e->get_text_length();
		}
	data_dg.clear();
	data_dg = e->get_text();
	tam = data_dg.length();
	if(isdigit(data_dg[tam-1]) || (data_dg[tam-1] == '/'))
		{
		if ((this->pos_entry > 0) && (this->pos_entry > tam))
			{
			this->pos_entry--;
			data_dg[tam]='\0';
			}
		else if (tam < 10)
			{
			if(mascara[tam] !='#')
				{
				data_dg += mascara [tam];
				}
			if((data_dg[tam-1] == '/')&&(data_dg[tam-2] == '/'))
				{
				data_dg[tam-1] = '\0';
				}
			tam++;
			}
		}
	else
		{
		data_dg[tam-1]='\0';
		tam--;
		}
	e->set_text(data_dg);
	this->set_posicao(e,tam);
	this->pos_entry = tam;
	}

void CADASTRO::checar_digito (Gtk::Entry *e)
	{
	string aux;
	int len;

	aux.clear();
	aux = e->get_text();
	len = aux.length();
	// entardatanas, entardatafec,entardatarev
	if(!isdigit(aux[len-1]) )  //para aceitar apenas numeros
		{
		aux[len-1]='\0';
		}
	e->set_text(aux);
	}

void CADASTRO::sel_colmeia ()
	{
	//id_col = 1;
	string AUX;
	AUX.clear();
	AUX = CBRcolmeia.get_text();
	cout << AUX << endl;
	}